Photoshop fuzzy zoom

I have been using photoshop for years and never really asked if this is normal. these are the three settings in zoom (print, fullscreen and actual pixels) does anyone else get this pixelated look on images that are not on actual pixels?[/img]

Yeah that happens. It's really annoying...

It's only logical that it does happen because you are trying to fit more pixels on the screen than can realistically fit. Think of it like this: Assuming your resolution is 1024 X 768 If your image is 2000 X 200 and you portray at actual pixel size you cannot view the whole thing at once since it would require your screen resolution to be equal to or exceed 2000 X 2000. If you set it to fit screen then it scales it down to 768 X 768 so that the whole thing can be seen on the screen - your computer does not AA this image so, depending on which pixels the computer ignores, the image could look blocky even tough it isn't. If your image PPI (pixels per inch) is greater than 72 then the Print size will be smaller than the actual pixel size since your screen works are 72 PPI therefore the same compression applies.

Isick really explains it good what happens.
Now the question rises why PS doesn't re-calculate the mean (by a math-algoritm) of a pixel value...

(If you don't know what I mean, try to google "image interpolation"... There are 3 popular mathematical algoritms to interpolate the value of a pixel:
- Bilinear
- Bicubic (smoother/sharper)
- Nearest neighbor

(Try searching this forum on these terms... I already posted a mathematical explanation or something like that)

The one that will render a pixelated look is the nearest neighbor algoritm. (the word explains itself)

So why isn't ps using a more interesting algoritm? Well, there probably will be a well argumented reason for that. I think the easiest algoritm is preferred... As a matter of memory saving...

You can set the algoritm that is applied (ONLY on the action when you resize/transform an image !!!) in the preferences tab... ^^

Hope this cleared out some " Why's ? "

IMP...

Yeah - I understand why it happens - I just don't understand why Photoshop isn't smart enough to fix this.

The funny thing is that sometimes it can - if I'm viewing at a magnification that's 50%, 25%, 12.5% etc it looks fine... But 66.7%, 33.3% etc has problems. It's almost like PS can handle halves but not thirds...

None of those images look pixelated to me. If you zoom up to 100% the image shouldn't be pixelated. If you change the canvas or image size to make the picture bigger, it will. I'm sure you know that though.

That's strange that it does it with thirds but not halves. I would suggest sticking to magnification in halves

That depends on how you define 'pixelated'....
--You see "pixelated" as over-sizing an image, so the result gets blocky,
--Un4given see "pixelated" as a lack of interpolation blending.

I will stick to Un4given's definition...


Q: And what about the thirds?
That's just simple math... It's all a matter of interference grids...

Lets start with explaining the scale variable...

You can define the fractions 1/1, 1/2, 1/4... all as decimal variables... It doesn't need a long integer to be exact as it is. You can keep adding as much zero's behind the dot, it won't change the value of the variable.

In stead of the fractions 1/3, 2/3... If you want to write these fractions as a decimal number, it will result in 33,3333... and 66,6666... But a variable can't contain infinite numbers behind the dot. And Photoshop even raws it up to 2 numbers behind the dot. (33,3333... -> 33,33 and 66,6666... -> 66,67)

[[Note: program variables are not meant to be written as a fraction, but mostly they are pre-designed integers with a set amount of numbers behind the dot ]]

And this way of cutting of numbers, will result in oscilating patterns in terms of math, due to a small difference from the fraction-value and the rounded value.

For example: try to open this grid in photoshop and play around with the scale factors. This will clear out most of the 'pixelated' effect.

This grid is a 1px wide, clear grid. And in combination with the previous named 'nearest neighbor' alogritm, it will lose lines at 'non uniform' scales.

( I like to define non uniform scales as scales that can't be written in a relative small fraction. f.ex:
0,25 --> 1/4 (uniform)..
0,24 --> 6/25 (non uniform) )

Maybe some more explanation about the 'nearest neighbor' term is needed.

This nearest neighbor algoritm, does nothing more than inherit the pixel color of the nearest pixel to a relative origin. A relative origin, is for example (as I used in next sketch) the left boundary of the actual pixel. ...

I've made a sketch to clear out:



Here I've drawn a uniform scale situation with a scale factor of 1/2. And a non uniform scale with a ROUNDED 1/3 scale factor. ( 33.30 - exagerated mistake to accentuate the effect)

Don't let your attention be lost in the actual pixel pattern... It has nothing to do with the point I like to explain... It's how the pixel gets is value, that is important for understanding this theoretically approach.

Now, in first situation, all the relative origines (the purple lines) are matching with pixel boundaries of the scaled pixels. So, as you can see, Every two scaled pixels, are as big as 1 actual pixel. Nearest neighbor will "drop" the unpair pixels in this example.

[[Note: Data gets lost. The result in this image is a full line, in stead of a dashed one... If the origin in the scaled situation, is shifted by 1 pixel, all the COLORED pixels will be dropped and nothing will be visible in actual pixels... This is what happens with the grid you can download ^^ ]]

So this means that EVEN with uniform scales you can have critical data loss, leading to (small amounts) of pixelation.

Now the second non uniform example in the image, shows us a same situation, but with a scale not completely equal to 1/3, but with a slight difference...
This will result in the fact that the relative neighbor origins will come upon a point, that the order of passed pixels will 'jump' to a scaled pixel that is ( due to rounding 33,33333 -> 33,30) not in the original sequence.... This will lead to irregular patterns. The frequency of this 'jumps' can be easily calculated, but I won't hussle you all with more maths ^^...

So this means that Non uniform scales lead to Irregular Pixelation, which is visible in images. That's the biggest negative point about the nearest neighbor algoritm. The positive point is that it's math algoritm is great amounts smaller than other algoritms, which logically lead to higher calculation speeds. I guess this is the reason for choosing this way of scaling.


[[Last note: The pixels discussed here and shown in the image are theoretical-pixels. We all know that one theoretical pixel has an equivalent of three physical pixels: a Red-, Green- and Blue-one]]

I hope I solved some aspects here, and that I haven't created to much confusion...
I know this isn't a math-forum, but these terms should be comprehensive for all of us...

IMP...

Wow, Imp - that's quite an explanation.

Don't you think, though, that it would be possible for Adobe to come up with a fix? Is it physically impossible to calculate the interpolation when it's in thirds?

Nearest neighbor after all DOES have advantages...

Like, try to make yourself an image of 1025 pixels wide (if your screen resolution is about 1024 x 768)

When you then want to see your image full screen (f.ex. in your browser - It uses Nearest Neighbor to !) it will resize it with a scale factor of 1025/1024. (( quite a large fraction ))

This will result in only one vertical row that will be "lost" in your image. You will barely notice.

If you would interpolate your image with another interpolation method, like "bi-cubic sharp", your image would become blurry after all. I should post a print screen of two results. Gonna do that in a moment.

So I guess the reason why adobe still uses a 'crappy' method is because of it's advantages in strange conditions.

Think about this: with any other interpolation method, NO ANNY original pixel will be inherited, in stead of the nearest neighbor technique were a quite large amount of original pixels will be inherited.

In graphical means of speaking, with this argument, nearest neighbor is the most conservative technique there is, although it looks crappy... So (In my opinion) there's no need for Adobe to fix this.

(( Now the question raises: What happens when the scale factor gets larger than 1. In physical terms: if you zoom in, instead of zooming out? ... I'm gonna retrieve the answer to that ^^ ))

IMP...

imp do you have some magical brain that just absorbs information... you seem to have atleast a decent contrubution to anything somebody asks lol

Like I said, I've resized an image on different scales with different interpolation techniques.

I've used the parameter in the image resize tab to set the interpolation method.



And in the preferences you can set your default interpolation method:





I've made an original 300 px wide picture with the previously shown grid and a few dots. This is my original image:



And this is how it looks like when I resize it in the three different basic methods: Nearest Neighbor, Bilinear and Bicubic

[[ Note: there are much more methods. Even more then Adobe uses. ]]

Click to see its original size. (otherwise you are distracted by the image-resize-interpolation that your browser uses. That is for IE and FireFox also the Nearest Neighbor technique)


As you can see, there are (many) lines missing in the NN method.

Q: Concerning the NN method, why is the number of horizontal dropped lines not equal to the number of vertical dropped lines?
A: Because the origin is not the left upper corner, but (I guess) the center of the image. Therefore, the origin could be shifted towards the horizontal lines in another way then it shifted towards the vertical lines.

Now watch how blurry an image gets when you resize it BL or BC. There aren't many differences between them, so I made you a difference map to show them:



[[Note: Difference maps are created by setting the blending mode of the top layer to Difference. Underneath it should be the layer you want to compare it to. ]]

I could explain all what it means (Bicubic and Bilinear etc.), but that isn't the Issue here.. So I'll save you from reading a too long theoretical piece of crap...

(( Afcourse I can Imagine some people are already skipping these post ^^ ))

Anyway, I like helping you out with my knowledge. So feel free to question me...

IMP...