forks
/
arsd
mirror of https://github.com/adamdruppe/arsd.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Finish downscaler implementation

This commit is contained in:
Elias Batek 2025-01-28 02:01:31 +01:00
parent b031783e84
commit 68a94f03c3
1 changed files with 236 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

333
pixmappaint.d
View File

@ -334,8 +334,7 @@ private float round(float f) pure @nogc nothrow @trusted {
## TODO: ## TODO:
- Refactoring the template-mess of blendPixel() & co. - Refactoring the template-mess of blendPixel() & co.
- Scaling - Rotating (by arbitrary angles)
- Rotating
- Skewing - Skewing
- HSL - HSL
- Advanced blend modes (maybe) - Advanced blend modes (maybe)
@ -422,6 +421,29 @@ struct UDecimal {
return UDecimal.make(rounded); return UDecimal.make(rounded);
} }
///
public UDecimal roundEven() const {
const truncated = (_value & 0xFFFF_FFFF_0000_0000);
const delta = _value - truncated;
ulong rounded;
if (delta == 0x8000_0000) {
const bool floorIsOdd = ((truncated & 0x1_0000_0000) != 0);
// dfmt off
rounded = (floorIsOdd)
? truncated + 0x1_0000_0000 // ceil
: truncated; // floor
// dfmt on
} else if (delta > 0x8000_0000) {
rounded = truncated + 0x1_0000_0000;
} else {
rounded = truncated;
}
return UDecimal.make(rounded);
}
/// ///
public UDecimal floor() const { public UDecimal floor() const {
const truncated = (_value & 0xFFFF_FFFF_0000_0000); const truncated = (_value & 0xFFFF_FFFF_0000_0000);
@ -2895,6 +2917,8 @@ enum ScalingFilter {
/++ /++
Bilinear interpolation Bilinear interpolation
(Uses arithmetic mean for downscaling.)
$(TIP $(TIP
Visual impression: “smooth”, “blurred” Visual impression: “smooth”, “blurred”
) )
@ -2931,7 +2955,6 @@ private static ScalingDirection scalingDirectionFromDelta(const int delta) @nogc
} }
private void scaleToImpl(ScalingFilter filter)(const Pixmap source, Pixmap target) @nogc { private void scaleToImpl(ScalingFilter filter)(const Pixmap source, Pixmap target) @nogc {
enum none = ScalingDirection.none; enum none = ScalingDirection.none;
enum up = ScalingDirection.up; enum up = ScalingDirection.up;
enum down = ScalingDirection.down; enum down = ScalingDirection.down;
@ -2943,6 +2966,7 @@ private void scaleToImpl(ScalingFilter filter)(const Pixmap source, Pixmap targe
(UDecimal(source.width) / target.width), (UDecimal(source.width) / target.width),
(UDecimal(source.height) / target.height), (UDecimal(source.height) / target.height),
]; ];
enum idxX = 0, idxY = 1;
// ==== Nearest Neighbor ==== // ==== Nearest Neighbor ====
static if (filter == ScalingFilter.nearest) { static if (filter == ScalingFilter.nearest) {
@ -2987,27 +3011,27 @@ private void scaleToImpl(ScalingFilter filter)(const Pixmap source, Pixmap targe
const posDst = Point(x.castTo!int, y.castTo!int); const posDst = Point(x.castTo!int, y.castTo!int);
const UDecimal[2] posSrc = [ const UDecimal[2] posSrc = [
(() @trusted => posDst.x * ratios.ptr[0])(), posDst.x * ratios[idxX],
(() @trusted => posDst.y * ratios.ptr[1])(), posDst.y * ratios[idxY],
]; ];
const int[2] posSrcX = () { const int[2] posSrcX = () {
int[2] result; int[2] result;
if (directions[0] == none) { if (directions[idxX] == none) {
result = [ result = [
posSrc[0].castTo!int, posSrc[idxX].castTo!int,
posSrc[0].castTo!int, posSrc[idxX].castTo!int,
]; ];
} else if (directions[0] == up) { } else if (directions[idxX] == up) {
result = [ result = [
min(sourceMaxX, posSrc[0].floor().castTo!int), min(sourceMaxX, posSrc[idxX].floor().castTo!int),
min(sourceMaxX, posSrc[0].ceil().castTo!int), min(sourceMaxX, posSrc[idxX].ceil().castTo!int),
]; ];
} else { } else /* if (directions[0] == down) */ {
const ratioXHalf = (ratios[0] >> 1); const ratioXHalf = (ratios[idxX] >> 1);
result = [ result = [
max((posSrc[0] - ratioXHalf).round().castTo!int, 0), max((posSrc[idxX] - ratioXHalf).roundEven().castTo!int, 0),
min((posSrc[0] + ratioXHalf).round().castTo!int, sourceMaxX), min((posSrc[idxX] + ratioXHalf).roundEven().castTo!int, sourceMaxX),
]; ];
} }
return result; return result;
@ -3015,31 +3039,34 @@ private void scaleToImpl(ScalingFilter filter)(const Pixmap source, Pixmap targe
const int[2] posSrcY = () { const int[2] posSrcY = () {
int[2] result; int[2] result;
if (directions[1] == none) { if (directions[idxY] == none) {
result = [ result = [
posSrc[1].castTo!int, posSrc[idxY].castTo!int,
posSrc[1].castTo!int, posSrc[idxY].castTo!int,
]; ];
} else if (directions[1] == up) { } else if (directions[idxY] == up) {
result = [ result = [
min(sourceMaxY, posSrc[1].floor().castTo!int), min(sourceMaxY, posSrc[idxY].floor().castTo!int),
min(sourceMaxY, posSrc[1].ceil().castTo!int), min(sourceMaxY, posSrc[idxY].ceil().castTo!int),
]; ];
} else { } else /* if (directions[idxY] == down) */ {
const ratioHalf = (ratios[1] >> 1); const ratioHalf = (ratios[idxY] >> 1);
result = [ result = [
max((posSrc[1] - ratioHalf).round().castTo!int, 0), max((posSrc[idxY] - ratioHalf).roundEven().castTo!int, 0),
min((posSrc[1] + ratioHalf).round().castTo!int, sourceMaxY), min((posSrc[idxY] + ratioHalf).roundEven().castTo!int, sourceMaxY),
]; ];
} }
return result; return result;
}(); }();
enum idxL = 0, idxR = 1;
enum idxT = 0, idxB = 1;
const Point[4] posNeighs = [ const Point[4] posNeighs = [
Point(posSrcX[0], posSrcY[0]), Point(posSrcX[idxL], posSrcY[idxT]),
Point(posSrcX[1], posSrcY[0]), Point(posSrcX[idxR], posSrcY[idxT]),
Point(posSrcX[0], posSrcY[1]), Point(posSrcX[idxL], posSrcY[idxB]),
Point(posSrcX[1], posSrcY[1]), Point(posSrcX[idxR], posSrcY[idxB]),
]; ];
const Color[4] pxNeighs = [ const Color[4] pxNeighs = [
@ -3049,6 +3076,8 @@ private void scaleToImpl(ScalingFilter filter)(const Pixmap source, Pixmap targe
source.getPixel(posNeighs[3]), source.getPixel(posNeighs[3]),
]; ];
enum idxTL = 0, idxTR = 1, idxBL = 2, idxBR = 3;
// ====== Faux bilinear ====== // ====== Faux bilinear ======
static if (filter == ScalingFilter.fauxLinear) { static if (filter == ScalingFilter.fauxLinear) {
auto pxInt = Pixel(0, 0, 0, 0); auto pxInt = Pixel(0, 0, 0, 0);
@ -3062,96 +3091,206 @@ private void scaleToImpl(ScalingFilter filter)(const Pixmap source, Pixmap targe
} }
} }
// ====== Proper bilinear ====== // ====== Proper bilinear (up) + Avg (down) ======
static if (filter == ScalingFilter.bilinear) { static if (filter == ScalingFilter.bilinear) {
// TODO: Downscaling looks bad as-is.
auto pxInt = Pixel(0, 0, 0, 0); auto pxInt = Pixel(0, 0, 0, 0);
foreach (immutable ib, ref c; pxInt.components) { foreach (immutable ib, ref c; pxInt.components) {
ulong[2] xSums; ulong sampleX() {
pragma(inline, true);
// ======== X ======== if (directions[0] == none) {
if (directions[0] == none) { return (() @trusted => pxNeighs[idxTL].components.ptr[ib])();
xSums = () @trusted { } else if (directions[0] == down) {
ulong[2] result = [ const nSamples = 1 + posSrcX[idxR] - posSrcX[idxL];
pxNeighs[0].components.ptr[ib], const posSampling = Point(posSrcX[idxL], posSrcY[idxT]);
pxNeighs[2].components.ptr[ib], const samplingOffset = source.scanTo(posSampling);
]; const srcSamples = () @trusted {
return result; return source.data.ptr[samplingOffset .. (samplingOffset + nSamples)];
}(); }();
} else if (directions[1] == down) {
xSums = [0, 0];
const UDecimal[2] deltasX = [ ulong xSum = 0;
posSrc[0] - posSrcX[0],
posSrcX[1] - posSrc[0],
];
const deltasXSum = (deltasX[0] + deltasX[1]).round().castTo!uint; foreach (srcSample; srcSamples) {
const UDecimal[2] weightsX = [ xSum += (() @trusted => srcSample.components.ptr[ib])();
deltasX[0] / deltasXSum, }
deltasX[1] / deltasXSum,
];
() @trusted { return (xSum / nSamples);
xSums[0] += (pxNeighs[0].components.ptr[ib] * weightsX[0]).round().castTo!uint; } else /* if (directions[0] == up) */ {
xSums[0] += (pxNeighs[1].components.ptr[ib] * weightsX[1]).round().castTo!uint; ulong xSum = 0;
xSums[1] += (pxNeighs[2].components.ptr[ib] * weightsX[0]).round().castTo!uint; const ulong[2] weightsX = () {
xSums[1] += (pxNeighs[3].components.ptr[ib] * weightsX[1]).round().castTo!uint; ulong[2] result;
}(); result[1] = posSrc[0].fractionalDigits;
} else { result[0] = ulong(uint.max) + 1 - result[1];
xSums = [0, 0]; return result;
}();
const ulong[2] weightsX = () { () @trusted {
ulong[2] result; xSum += (pxNeighs[idxTL].components.ptr[ib] * weightsX[0]);
result[1] = posSrc[0].fractionalDigits; xSum += (pxNeighs[idxTR].components.ptr[ib] * weightsX[1]);
result[0] = ulong(uint.max) + 1 - result[1]; }();
return result;
}();
() @trusted { return (xSum >> 32);
xSums[0] += (pxNeighs[0].components.ptr[ib] * weightsX[0]);
xSums[0] += (pxNeighs[1].components.ptr[ib] * weightsX[1]);
xSums[1] += (pxNeighs[2].components.ptr[ib] * weightsX[0]);
xSums[1] += (pxNeighs[3].components.ptr[ib] * weightsX[1]);
}();
foreach (ref sum; xSums) {
sum >>= 32;
} }
} }
// ======== Y ======== ulong[2] sampleXDual() {
if (directions[1] == none) { pragma(inline, true);
c = clamp255(xSums[0]);
} else if (directions[1] == down) {
const UDecimal[2] deltasY = [
posSrc[1] - posSrcY[0],
posSrcY[1] - posSrc[1],
];
const deltasYSum = (deltasY[0] + deltasY[1]).round().castTo!uint; if (directions[0] == none) {
const UDecimal[2] weightsY = [ return () @trusted {
deltasY[0] / deltasYSum, ulong[2] result = [
deltasY[1] / deltasYSum, pxNeighs[idxTL].components.ptr[ib],
]; pxNeighs[idxBL].components.ptr[ib],
];
return result;
}();
} else if (directions[0] == down) {
const nSamples = 1 + posSrcX[idxR] - posSrcX[idxL];
const Point[2] posSampling = [
Point(posSrcX[idxL], posSrcY[idxT]),
Point(posSrcX[idxL], posSrcY[idxB]),
];
auto ySum = UDecimal(0); const int[2] samplingOffsets = [
ySum += ((xSums[0] & 0xFFFF_FFFF) * weightsY[0]); source.scanTo(posSampling[0]),
ySum += ((xSums[1] & 0xFFFF_FFFF) * weightsY[1]); source.scanTo(posSampling[1]),
];
c = clamp255(ySum.round().castTo!uint); const srcSamples2 = () @trusted {
} else { const(const(Pixel)[])[2] result = [
source.data.ptr[samplingOffsets[0] .. (samplingOffsets[0] + nSamples)],
source.data.ptr[samplingOffsets[1] .. (samplingOffsets[1] + nSamples)],
];
return result;
}();
ulong[2] xSums = [0, 0];
foreach (idx, srcSamples; srcSamples2) {
foreach (srcSample; srcSamples) {
() @trusted { xSums.ptr[idx] += srcSample.components.ptr[ib]; }();
}
}
xSums[] /= nSamples;
return xSums;
} else /* if (directions[0] == up) */ {
ulong[2] xSums = [0, 0];
const ulong[2] weightsX = () {
ulong[2] result;
result[1] = posSrc[0].fractionalDigits;
result[0] = ulong(uint.max) + 1 - result[1];
return result;
}();
() @trusted {
xSums[0] += (pxNeighs[idxTL].components.ptr[ib] * weightsX[0]);
xSums[0] += (pxNeighs[idxTR].components.ptr[ib] * weightsX[1]);
xSums[1] += (pxNeighs[idxBL].components.ptr[ib] * weightsX[0]);
xSums[1] += (pxNeighs[idxBR].components.ptr[ib] * weightsX[1]);
}();
foreach (ref sum; xSums) {
sum >>= 32;
}
return xSums;
}
}
ulong sampleXMulti() {
pragma(inline, true);
const nLines = 1 + posSrcY[idxB] - posSrcY[idxT];
ulong ySum = 0;
alias ForeachLineCallback = ulong delegate(const Point posLine) @safe pure nothrow @nogc;
ulong foreachLine(scope ForeachLineCallback apply) {
ulong linesSum = 0;
foreach (lineY; posSrcY[idxT] .. (1 + posSrcY[idxB])) {
const posLine = Point(posSrcX[idxL], lineY);
linesSum += apply(posLine);
}
return linesSum;
}
if (directions[0] == none) {
ySum = foreachLine(delegate(const Point posLine) {
const pxSrc = source.getPixel(posLine);
return ulong((() @trusted => pxSrc.components.ptr[ib])());
});
} else if (directions[0] == down) {
const nSamples = 1 + posSrcX[idxR] - posSrcX[idxL];
ySum = foreachLine(delegate(const Point posLine) {
const samplingOffset = source.scanTo(posLine);
const srcSamples = () @trusted {
return source.data.ptr[samplingOffset .. (samplingOffset + nSamples)];
}();
ulong xSum = 0;
foreach (srcSample; srcSamples) {
xSum += (() @trusted => srcSample.components.ptr[ib])();
}
return xSum;
});
ySum /= nSamples;
} else /* if (directions[0] == up) */ {
const nSamples = 1 + posSrcX[idxR] - posSrcX[idxL];
ySum = foreachLine(delegate(const Point posLine) {
ulong xSum = 0;
const ulong[2] weightsX = () {
ulong[2] result;
result[1] = posSrc[0].fractionalDigits;
result[0] = ulong(uint.max) + 1 - result[1];
return result;
}();
const samplingOffset = source.scanTo(posLine);
ubyte[2] pxcLR = () @trusted {
ubyte[2] result = [
source.data.ptr[samplingOffset].components.ptr[ib],
source.data.ptr[samplingOffset + nSamples].components.ptr[ib],
];
return result;
}();
xSum += (pxcLR[idxL] * weightsX[idxL]);
xSum += (pxcLR[idxR] * weightsX[idxR]);
return (xSum >> 32);
});
}
return (ySum / nLines);
}
if (directions[idxY] == none) {
c = clamp255(sampleX());
} else if (directions[idxY] == down) {
c = clamp255(sampleXMulti());
} else /* if (directions[idxY] == up) */ {
// looks ass
const ulong[2] weightsY = () { const ulong[2] weightsY = () {
ulong[2] result; ulong[2] result;
result[1] = posSrc[1].fractionalDigits; result[idxB] = posSrc[1].fractionalDigits;
result[0] = ulong(uint.max) + 1 - result[1]; result[idxT] = ulong(uint.max) + 1 - result[idxB];
return result; return result;
}(); }();
const xSums = sampleXDual();
ulong ySum = 0; ulong ySum = 0;
ySum += (xSums[0] * weightsY[0]); ySum += (xSums[idxT] * weightsY[idxT]);
ySum += (xSums[1] * weightsY[1]); ySum += (xSums[idxB] * weightsY[idxB]);
const xySum = (ySum >> 32); const xySum = (ySum >> 32);