For me, it's Catmull-Rom.

For me, it's Catmull-Rom.

The Kind of Tired That Sleep Won’t Fix Shirt $21.68

Tip Your Landlord Shirt $21.68

The Kind of Tired That Sleep Won’t Fix Shirt $21.68

  1. 1 month ago
    Anonymous

    this looks like they were scaled without being gamma corrected first

    • 1 month ago
      Anonymous

      Gamma correction is a meme, most applications like image viewers and media players don't even apply gamma correction while scaling.

      • 1 month ago
        Anonymous

        that's nice but the ones i use do

      • 1 month ago
        Anonymous

        Absolute midwit take. Everything looks darker than nearest without it.

        • 1 month ago
          Anonymous

          >noooo everything must be linearized because.. because it's incorrect otherwise!!
          holy midwit. As i already said, your browser doesnt linearize while scaling, youtube's player don't linearize while scaling, your image viewer doesn't linearize while scaling, VLC/ffplay doesn't linearize while scaling. Your attempts to get "correct" results are futile, and no one in the industry cares. Even studios who print 1080p BDs (which are just downscales from 4K masters) aren't linearized. They're all gamma uncorrected.

          • 1 month ago
            Anonymous

            Cope.

    • 1 month ago
      Anonymous

      The pixels could do with being converted from RGB to HSL before being interpolated. The results here look muddy.

  2. 1 month ago
    Anonymous

    >caring about this in the age of AI upscaling and coloring everything easily

    • 1 month ago
      Anonymous

      >age of AI upscaling and coloring everything
      Even you know this is bullshit, because if this was true then simple acts such as window scaling would be unbearably slow. Tensor cores aren't magic and will always be leagues slower and more inefficient than fixed-hardware GPU interpolation

    • 1 month ago
      Anonymous

      AI upscaling is heavy and looks like shit at anything lower than 1080p

      If you're using anything but None/Nearest at integer values for upscaling you're doing it wrong.
      If you're downsampling, well, that's more forgiving.

      Nearest is only good in pixel art

  3. 1 month ago
    Anonymous

    If you're using anything but None/Nearest at integer values for upscaling you're doing it wrong.
    If you're downsampling, well, that's more forgiving.

    • 1 month ago
      Anonymous

      Pixels aren't squares. Also you will get uneven pixel sizes/image warping if you nearest-neighbor scale to a noninteger factor, which is a very common issue for emulation. The main reason why all of these pointless resampling algorithms even exist is because nearest-neighbor looks like shit.

      that's nice but the ones i use do

      Bullshit. Linearization is too slow for most low-power hardware like shittops and shitphones. There is no application that defaults to gamma-correction for compatibility reasons.

      • 1 month ago
        Anonymous

        >Linearization is too slow
        what? no it isn't. if you benchmark it with ffmpeg or mpv you'll see it doesn't even affect frame times because the bottleneck is memory speed unless you're using a meme scaler

        • 1 month ago
          Anonymous

          ffplay doesn't even default to linearized scaling. And neither does mpv.

      • 1 month ago
        Anonymous

        >Pixels aren't squares
        Pixels are pixels and are pixels.
        Pixels will always be pixels.
        You can represent them as dots to manifest them into the real world, or with RGB stripes, or with pantone color squares under D50 illuminants for a tiled mosaic.

        When it comes to RESAMPLING pixels, there's no good way to upsample them. Just enlarge the pixels, and be done with it.
        If you have a pipeline that treats them as squares (digital displays, typically, despite them being RGB stripes in physical form in the real world) then you just turn one square into 4 squares to zoom in 2x.

        >Also you will get uneven pixel sizes/image warping if you nearest-neighbor scale to a noninteger factor
        No shit.
        If you must do this bad thing, then it doesn't really matter what you use, the end result will be pretty shit regardless.

        >The main reason why all of these pointless resampling algorithms even exist is because nearest-neighbor looks like shit.
        No, they're simply using it wrong.
        NN+Integer values looks perfect, if you think it looks bad, then that's your content that looks bad and you're misplacing blame. Pixelation ain't such a good look, but it sure beats blur or AI slop.

    • 1 month ago
      Anonymous

      >if you're not doing [objectively shittiest option] you're doing it wrong

      • 1 month ago
        Anonymous

        thats how you get yous!! say the stupidest "wrongest" shit ever and receive the dopamine

    • 1 month ago
      Anonymous

      This. NN when upscaling, lanczos when downscaling.

  4. 1 month ago
    Anonymous

    For me, none and nearest

  5. 1 month ago
    Anonymous

    for me it's integer nearest neighbor.
    It's annoying when i'm making "pixel" art projects and having to prevent browsers from doing something moronic by default. it's insane.

  6. 1 month ago
    Anonymous

    ARR ROOK SAME!!

  7. 1 month ago
    Anonymous

    bilinearbros ww@
    all nearest neighbour Black folk must fricking hang

  8. 1 month ago
    Anonymous

    They all look moronic, what fricking use case would someone need for those?

  9. 1 month ago
    Anonymous

    For me, it's rendering onto a buffer 1/10th the size the assets were designed for and then up-scaline using Bilenear because I'm too lazy to learn how real console limitations work and I need to jump on the PS1/N64 era nostalgia wave before it's too late.

    • 1 month ago
      Anonymous

      neither the ps1 nor n64 used bilinear interpolation

      • 1 month ago
        Anonymous

        trust me bro, this is retro. just add some inappropriate dithering and some high-contrast neon colors like totally all of the PS1 and N64 games had

        • 1 month ago
          Anonymous

          both consoles had dithering, most games output 15bit colour, though you're unlikely to notice dithering with n64 games due to the hardware anti-alias filter which blurs... everything

          N64 had a filtering that was like bilinear but worse. Both Mupen and Duckstation have options for bilinear texture filtering and in full 3D games it actually looks pretty good

          the n64 has a rather unique "3 point" bilinear filter, rather than the normal 4 point bilinear, the difference is quite obvious when looking at a texture close up, which you always do on the n64 since the textures were so small
          the psx uses a point filter, or in modern terms, no filter, which is easy to replicate, but psx has its' own challenges in terms of replicating how its' graphics worked, notably the fact textures are affine transformed, no perspective correction, and also the fact the 3D math is all done in fixed-point, since it has no floating point unit, making vertices very "wobbly"

          • 1 month ago
            Anonymous

            Good thing modern emulators can eliminate the wobbliness of PS1 games.

          • 1 month ago
            Anonymous

            Yeah, so great that it's possible to intentionally make your game look like complete shit.

          • 1 month ago
            Anonymous

            it's crazy what modern psx emulators can do

            stable vertices and perspective textures are nothing special on n64 emulators, since the n64 did those on its own, it's not trivial at all to implement them in a psx emulator

      • 1 month ago
        Anonymous

        N64 had a filtering that was like bilinear but worse. Both Mupen and Duckstation have options for bilinear texture filtering and in full 3D games it actually looks pretty good

        • 1 month ago
          Anonymous

          both consoles had dithering, most games output 15bit colour, though you're unlikely to notice dithering with n64 games due to the hardware anti-alias filter which blurs... everything
          [...]
          the n64 has a rather unique "3 point" bilinear filter, rather than the normal 4 point bilinear, the difference is quite obvious when looking at a texture close up, which you always do on the n64 since the textures were so small
          the psx uses a point filter, or in modern terms, no filter, which is easy to replicate, but psx has its' own challenges in terms of replicating how its' graphics worked, notably the fact textures are affine transformed, no perspective correction, and also the fact the 3D math is all done in fixed-point, since it has no floating point unit, making vertices very "wobbly"

          it's worth noting that simply using normal bilinear isn't necessarily an upgrade, games were sometimes made to work around the look of 3 point filtering, which you lose if you do that, plus just in general it doesn't look the same, using bilinear just "looks like it's emulated", since that's all emulators could do for a long time

          Good thing modern emulators can eliminate the wobbliness of PS1 games.

          i was so amazed when i first heard about that, at first i wondered why emulators didn't fix that, then i read into why it happens, so for a long time i understood that it wasn't possible, then they go and find a way anyway

          Yeah, so great that it's possible to intentionally make your game look like complete shit.

          i think you misread his point, he said "eliminate", not "emulate". until recently emulators reproduced the same wobbly vertices and not because of some desire to be faithful, but because it was an actual technical limitation of the console, all the math was done with integers, so while you could scale the graphics up, vertices were still stuck on the original, very coarse integer grid

          • 1 month ago
            Anonymous

            Overlay is beautiful and crisp on the right. Looks like shit on left.
            Clever filtering makes the edge of stairs look great.

  10. 1 month ago
    Anonymous

    >none

  11. 1 month ago
    Anonymous

    Just use ewa_lanczossharp with AR until the AI scalers catch up in accuracy and power consumption

  12. 1 month ago
    Anonymous

    none/nearest looks best.
    Everything else is a blurry mess.

    • 1 month ago
      Anonymous

      nooooooo
      you heckin have to resamplerino the pixelerinos, they're not actually squares! they can be blurred and stretched to look not pixelated!!!
      seriously
      just resizing the pixels is very BAD because you can see pixels! okay?

      • 1 month ago
        Anonymous

        >okay?
        What are you asking?

        • 1 month ago
          Anonymous

          ACCEPT THAT WE MUST BLUR THE PIXELS
          LUDDITE

          gosh
          ur so stubern and stupit
          the human eye does not see in pixels

          if you look at computer screen or television and don't have to ask "what the frick am I looking at?" you are doing it wrong and need to blur the pixels more until that happens

          • 1 month ago
            Anonymous

            Did you fail your computer graphics course or something? What's with this unbridled seething at basic low-pass filtering?

  13. 1 month ago
    Anonymous

    People yearn for the seams.

  14. 1 month ago
    Anonymous

    nice artificial test case
    now show some comparisons of real-world samples

  15. 1 month ago
    Anonymous

    I like Lanczos because the painterly effect is cool

    • 1 month ago
      Anonymous

      Painterly effect? You mean the antialiasing?

      • 1 month ago
        Anonymous

        yes

  16. 1 month ago
    op is a fag

    I like spline36 and lanczos, altough they are a bit too slow, in which case I'd rather use catmull-rom, then mitchell, then hermite

  17. 1 month ago
    Anonymous

    scale=ewa_lanczossharp
    dscale=catmull_rom

  18. 1 month ago
    Anonymous

    there's a thread on /gif/ where the OP is a webm of a girl shitting out candy and that shit looks like pic related

  19. 1 month ago
    Anonymous

    >scan drawing I made in 1200dpi
    >decide that its too wide, scale it lower horizontally
    Is there any point to using something besides nearest? At that resolution I don't think it's noticeable either way and in the end it will then get scaled down to something that actually fits on a computer screen.
    I also kind of like the sharp look of scaling down with nearest

    • 1 month ago
      Anonymous

      uneven pixel sizes

      • 1 month ago
        Anonymous

        But I'm scaling it down from an absurdly high resolution anyway

        • 1 month ago
          Anonymous

          you're still going to encounter that issue, and even worse, your image will be full of high contrast and high frequency information, which means bad moire and aliasing.

        • 1 month ago
          Anonymous

          you're still going to encounter that issue, and even worse, your image will be full of high contrast and high frequency information, which means bad moire and aliasing.

          m-n for comparison

    • 1 month ago
      Anonymous

      If you're downsampling, use bicubic or something at least.
      Unless you're downsampling by integers, like taking a 1200 DPI scan of an 8x10 drawing and turning it into a square, you can scale that by integers down.

      8x1200=9600
      10x1200=12000

      If you scaled this image down to 2400x2400, you can do 25% width and 20% height, integer scaled with NN or Linear with good results.
      If you do anything even scaling a 1600x900 image into 1280x720 NN won't do good. Use bicubic or leave it in original size, and leave the future user to resample/display as desired without baking scaling artifacts into the original content.
      In general, always avoid scaling. It's always bad.
      Even a small adjustment like changing a 4000x4800 image into 4000x4600 will scale ALL the pixels slightly and cause issues.

Your email address will not be published. Required fields are marked *