3

Just putting this out there for discussion, and because I can't currently think of why it wouldn't work...

Imagine you converted every pixel of a bitmap image into a vector square. Could you then resize that image (or the collection of vector square "pixels") proportionally and infinitely, essentially creating a vector-bitmap image?

What would be the limitations or hindrances of this?

If it's possible, couldn't it be implemented anywhere and everywhere (eg. like svg for websites, etc.) so we no longer have the "raster-images-get-blurry-when-enlarged" problem? Some sort of automatic conversion tool (ie. open/import a bitmap image and it's automatically "read" and converted to a vectorized-pixel image), even within Photoshop itself, that could turn any old raster image into a fully responsive vector-pixel image?

Why hasn't this happened yet?

Pixels

Improve this question
11
  • Something like here: graphicdesign.stackexchange.com/questions/20397/…? – Takkat May 4 '16 at 19:28
  • I'm less interested in a "how-do-I" answer, than I am a discussion on the concept, and why, if possible, vector-pixel images are not a thing? Asking per this challenge: meta.graphicdesign.stackexchange.com/questions/2952/… – dmoz May 4 '16 at 19:37
  • This website follows a pretty strict Q & A format. As such, open-ended, discussion questions are usually not a good fit and I can foresee this getting closed. More information on the types of questions to avoid can be found here – Manly May 4 '16 at 19:44
  • 1
    @dmoz a raster image can be enlarged just as much as a vectorized pixel image. the 'pixels' still increase in size with the vector solution. Theres no diference. – Cai May 4 '16 at 20:19
  • 1
    I think this is a valid question and doesn't seem that broad – Zach Saucier May 4 '16 at 20:25
4

It wouldn't really add anything. That is what pixel images are anyway, a map of discrete colored squares, exactly the same as if you converted each pixel to a vector square.

Take this image from my answer on a previous question asking how to do exactly what you are talking about:

256 pixel tile increased to 6400 pixels

That is a 256 pixel square tile increased in size to 6,400 pixels square, with apparently no loss in image quality. As long as you increase the size of the image in integer multiples, you get no apparent loss in quality. What you will never get is an increase in quality (which is what people who don't understand the nature of bitmap images may expect)

The loss in quality you get from increasing the size of an image comes from anti-aliasing and interpolation... But, the important thing here is, you would also get that with your vectorized pixels!

Vector images still need to be rasterized or rendered for you to see them on your screen, which means any vector image you see has at that point been turned in to a pixel based image. Your screen is made up of pixels after all. And since your vector/bitmap hybrid image is basically still made up of pixels, you still get the same effects.

Here are some comparisons of images being enlarged with different methods:

Interpolation comparisons

The first enlargement is with no interpolation, which preserves the sharpness. The problem with this is that the sharpness is just enlarged pixels, which is generally what people don't want. The second enlargement is done using bicubic interpolation. This gets around the pixelation problem, but the result is a distortion that most of the time looks worse. There are better algorithms and methods for enlarging images but that is a whole other subject!

Improve this answer
6
  • That's a very interesting example. I get that the physical pixels in a screen require anything it shows to be rendered into pixels, but I guess why couldn't the same concept as your example be applied to any image? Ie. Why can't we have responsive images? For example: a 256x256px image on the web is made responsive via CSS and enlarged to 6,400x6,400px. If the image pixels, growing ever-larger, dictated which screen pixels displayed which colors—the screen pixels "chop" up the image pixels down to even the tight Retina density we currently have—couldn't the sharpness be retained? – dmoz May 4 '16 at 20:46
  • Better yet, not even in integer multiples. With our current screen pixel densities, does it have to be enlarged in exact multiples to still retain sharpness? Could our screens (or some hypothetical algorithm) average the colors to be displayed between the enlarged image pixels? ....... Thanks for all the answers/discussion. Just trying to wrap my head around this. – dmoz May 4 '16 at 20:49
  • Averaging the colors is, literally, what resampling is. Your basic idea is, quite literally, what image resampling is. There is absolutely no difference between the current reality of image manipulation and your idea. – Yorik May 4 '16 at 21:14
  • @dmoz as Yorik said, what you are saying is exactly what happens. Those algorithms aren't hypothetical they are the exact reason you get that blurriness when you enlarge images. You can retain the sharpness as you said, but that is the sharpness of the pixels which is what people don't generally want. – Cai May 4 '16 at 21:33
  • @Yorik, I hear you, thanks. @ Cai, I guess I'm picturing a case even beyond the bicubic interpolation example you posted above. If we had the screen pixel density, and the image itself was sharp enough in the first place—packed with enough ppi, and we refined the contrast of our algorithmic sharpening/resampling, couldn't we at least reproduce exactly the sharpness of the original image? Thanks for the discussion gents! – dmoz May 5 '16 at 14:53
6

As you put it, vectorizing every pixel makes no sense.

Imagine you vectorize every pixel and then resize it. You simply have bigger squares.

The exact same thing happens if you change the ppi on an output, you have bigger pixels. You do not need to resample it.

You want to get rid of the blurriness. That is a totally different issue. That happens when the user (or software) uses a resampling method that simply tries to guess the information that is not there, so the result can be blurry.

There is one resampling method that does not blur the image, it simply gives you bigger pixels, that is resampling at an exact proportion 2x, 3x using nearest neighbour. But this has no sense either, because you simply have a bigger file with no extra value. It is only to give an image a pixelated look.

There are some resampling algorithms that "vectorize" the bitmap (they claim that), like

  • Photozoom
  • Reshade
  • Alien Skin

That finds the edges of a shape, and does not blur them. But the results are not perfect, and they work in some situations, not all of them.

There is other software that guesses the pattern below an image. They work in some situations, but again not perfect.

Here is a sample image,

The first square has no blurriness, it has pixelation... bigger pixels (the exact same case as your proposal). The other 3 are different methods of resampling.

  • Irfanview, Lanczos Filter
  • PhotoZoom
  • Reshade

Improve this answer
2
  • That PhotoZoom enlargement looks really good! I'm actually impressed. – Cai May 4 '16 at 22:42
  • That test was made with the version 4 I think. There is a chance it got better. – Rafael May 5 '16 at 0:18

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.