PointSize: A collection of pixel scaling filters

[`Orum]

PointSize is a collection of specialized resizers for pixel-art and other low resolution graphics (e.g. old or portable video game captures).

Download v0.2 (or scroll down to download it from the attached files)
Note: Requires Visual C++ Redistributable for Visual Studio 2015 if you don't already have it installed.

The readme:

+-----------------------------------------------------------------------------+
|   PointSize v0.2 - A collection of resiziers for AviSynth 2.6 / AviSynth+   |
+-----------------------------------------------------------------------------+

Filters
-----------------
PointSize contains the following filters:
  scalex(clip c, int scale=2) - Scale (e.g. Scale2x) resize
  LQx(   clip c, int scale=2) - LQ (e.g. LQ2x) resize
  HQx(   clip c, int scale=2) - HQ (e.g. HQ2x) resize
  xBRZ(  clip c, int scale=2, float Yweight=1, float EqColorTol=30, \
    float DomDirThresh=3.6, float SteepDirThresh=2.2) - xBRZ resize

Supported "scale" values for various filters (inclusive):
  scalex(): 2 to 3
  LQx():    2 to 4
  HQx():    2 to 4
  xBRZ():   2 to 6

ALL filters take ONLY RGB32 input and produce ONLY RGB32 output.

For an explanation of the various filters, please see:
  https://en.wikipedia.org/wiki/Image_scaling


FAQ
-----------------
Q: Do you plan to support more color spaces (e.g. YV12)?
A: No.  Use the various converting functions in AviSynth (e.g. ConvertToRGB32()
   and ConvertToYV12()) if you need to use other source/destination spaces.

Q: Do you plan to support more algorithms?
A: Yes.  However, I am limiting myself to those that already have at least some
   working C/C++ or assembly (must support x86 and x64) implementation.  While
   HLSL and GLSL versions of algorithms are fast, they require a graphics card
   and I don't want that to be a prerequisite to use this filter.  If you know
   of an implementation of an algorithm that is not included, and it works and
   is license compatible, or you'd like to write your own for this purpose,
   don't hesitate to contact me and I can include it in a new release.  In
   particular, I'm looking to support the following algorithms, license
   permitting: EPX, AdvMAME2/3, [Super]Eagle, [Super]2xSaI, xBR, and Kopf-
   Lischinski.


License
-----------------
PointSize is licensed under the GPLv3, which is included along with the source
code for the program.

Change log:

v0.2
	Restructured so that each algorithm family has only a single function, with a scale parameter
	Added support for the xBRZ algorithm, including support for tweaking its parameters
	License changed to GPLv3 due to inclusion of the xBRZ algorithm
	Resource added to include file version information within the DLL
	Plugin is now updated for AviSynth 2.6 / AviSynth+
	64-bit binaries are now included in the release (in addition to x86)
	Binaries are built with a newer version of MSVS (2015)
	Cleaned up code a bit (negligible or no effect on the binary)

v0.1
	Initial release

Please let me know what you think below.

[Guest]

Attaching for easier access. Thank you for your contribution.

Any plans for other color spaces?

[`Orum]

I was thinking about it...I don't see any reason why it couldn't work, but I don't know if the interpolation will work as well in something like 4:2:0. I might have to adjust it or maybe it will work right off the bat--but, I imagine most things scaled with these filters will at least be captured in RGB24/32 to begin with, so it's low priority.

First I want to try and understand how the SaI family of resizers is supposed to work without accessing invalid memory ...

[Terka]

how to load the plugin?

[Guest]

loadplugin("pointsize.dll")

[wonkey_monkey]

Hey, excellent, I looked into implementing these algorithms in AviSynth a while ago but didn't get around to it... so thanks for saving me the trouble

David

[`Orum]

New release out, v0.2, with the main changes being AviSynth 2.6 / AviSynth+ support (with 64 bit binaries to boot), as well as support for another algorithm: xBRZ.

[filler56789]

^ Many thanks for the update

[MysteryX]

How about providing image comparison samples?

[TheFluff]

Originally Posted by MysteryX

How about providing image comparison samples?

hq2x/xbrz and friends are very well known algorithms, comparison images are just a google search away (or you can just check wikipedia like the readme suggests, hqx even has its own article)

that said, if you haven't heard of them you're probably not in the target audience for this filter

[MysteryX]

Originally Posted by TheFluff

hq2x/xbrz and friends are very well known algorithms, comparison images are just a google search away (or you can just check wikipedia like the readme suggests, hqx even has its own article)

that said, if you haven't heard of them you're probably not in the target audience for this filter

It does make old video games look a LOT better!

[Bloax]

That highly depends on the content of said game.


Shit like this will get butchered to high hell.

[raffriff42]

Originally Posted by Bloax

...will get butchered to high hell.

I dunno, bloax, depends on what you are looking for.





(PS, a simple BicubicResize has a look somewhere between LQ2x and scale2x)

[Bloax]

Well yes, there we go. None of them look any better than straight-up pointresize due to ruining the shapes and barely doing anything else (unless it's hq2x, in which case it also blurs very detailed bits to make them not detailed).

They only manage to look worse, and even bigshot XBR that works wonders on a lot of things completely botches this stuff.

I'm simply making too detailed and too complicated things for these low-detail pixel art upscalers to survive.

[raffriff42]

Originally Posted by Bloax

I'm simply making too detailed and too complicated things for these low-detail pixel art upscalers to survive.

You are indeed, and they are lovely too.

[`Orum]

Originally Posted by raffriff42

I dunno, bloax, depends on what you are looking for.

<snip>

You have LQ2x in there twice, and no xBRZ?

Anyway, yes, there will never be a "one resizer fits all", and different people have different tastes. I'd love to include some more algorithms to provide more options, but my time is quite limited (in case you couldn't tell by the > 5.5 years between releases).

I'm mostly looking at other programs that already implement the filters (e.g. MAME) and trying to get them into AviSynth, but there are often challenges in doing so, as they'll often lack support for things like input/output pitch. It shouldn't be too hard to fix for the older algorithms, but some of the newer ones are still under active development, like xBR. In addition, xBR is written in HLSL, and the only port to C++ that I know of is an old version of the algorithm. If I ever get through updating the multitude of other software/hardware projects I'm working on (hah!), maybe I'll even port it myself.

[MysteryX]

Originally Posted by `Orum

In addition, xBR is written in HLSL, and the only port to C++ that I know of is an old version of the algorithm. If I ever get through updating the multitude of other software/hardware projects I'm working on (hah!), maybe I'll even port it myself.

Until then, it can run with AviSynthShader

[raffriff42]

Originally Posted by `Orum

You have LQ2x in there twice, and no xBRZ?

Whoa, so I do. I also forgot to download version 0.2. So to make good, here are some new images.

Also included are Bicubic, nnedi3_rpow2, and my function, which I can't take full credit for, pow2Qt.





xBRZ is pretty great, but it does go crazy sometimes.

Thx Bloax for your images.

Here's another one from the old video game "F117A" running on DOSBOx.
It puts a premium on antialiasing diagonal lines.

[Hyllian]

For fun:

[Bloax]

If you guys want to have fun with that thing without the limited palette fucking things up to some degree,

here you go. (Just make sure to scale it down to its original resolution, obviously.)

Some of the little details get wiped out due to the obviously limited amount of shades a certain tone has.


And here's a more kind image.

Looks quite nice when run through 4xbrlv4 and pointresized to halve the resolution.

The blue armored one is hardly news - the main offender among the scaling algorithms is that heavy dithering makes them fall apart.
The other one showcases that a ton of very intricate details and line flows also makes them take a dump on the quality, since they're there for a reason.