[fidotron]

This fuss about the iPhone screens is, to me at least, hilarious.

A good part of my career has been being the "Android guy" in organisations where for better or worse the products would de facto lead on iOS. The number one headache was designers pushing "pixel perfect design" which is doable on Android, but is a pointless headache when your tiny screen is 720p or higher.

The fact Apple have a phone coming out for which it is actually impossible is going to send a lot of these people into a confused fit. If this was how Android worked it would be criticised to the hills, but because it's Apple they can't.

[MCRed]

Since the points are rendered in pixel-perfect form and then down sampled on the iPhone 6+, the only potential loss of fidelity is in the downsampling step. Since we're in an age of not even being able to see pixels, there should be no fidelity loss. The image displayed will be rendered at a higher resolution than the display, and thus every pixel on the ultimate display will be "perfect". Back when pixels were big enough to see, I was one of those "pixel perfect" people too. You had to get it right, or the error was noticeable. With retina displays, this is much less of an issue. (to me at least)

I have seen android devices advertised with 4k displays at a 4-5" diagonal form actor. That doesn't make sense to me, because beyond 300dpi there isn't much point in higher pixel density. Yes, it makes sense for Apple to choose this size display (as 1080p is a commodity size).

The real issue is, if you want to compare the platforms, which platform has better resolution independence support.

I won't criticize android on this, but I will say that the iOS reliance on PNGs has gone on way too long. 2x was a decent solution for photographs... but we should have moved to SVG or some vector format as a native format in iOS several years ago.

[mrb]

"there should be no fidelity loss"

Heh. Yes there will be, most notably on webpages, for example those with box borders defined as "1px solid" lines. The lines will look fuzzy and unequal. Check the last image at http://www.paintcodeapp.com/content/news/2014-09-11_iphone-6... : it shows a "1 CSS pixel" line rendered as 2 black lines + 2 grey lines (one of the greys is very, very light). Some lines will not be interpolated the same way: some will be 2 black lines + 1 grey line, some will be 1 black line + 2 grey lines, and the shade of the 2 greys will be unequal and will vary depending on their precise alignment on the 1080p physical grid. The end result is that some lines will look slightly thinner/lighter or slightly thicker/darker than others. Heck, on my Nexus 5 which has an even higher PPI (445 PPI) than the iPhone 6+ (401 PPI) I can still clearly notice this effect, when holding the phone at arm's length (and I don't even have 20/20 vision), when simulating the downsampling that the 6+ is going to have to do. I can do it by zooming out[1] to simulate an effective pixel ratio of ~2.61, which is equivalent to what the iPhone 6+ is really doing graphically (1080 physical pixels wide / 414 logical pixels wide = ~2.61).

Contrast this with most Android devices where it is possible to get pixel perfect rendering because most (but not all) of them use a non-fractional pixel ratio (1.0, or 2.0, or 3.0, or 4.0) and to my knowledge none do downsampling (though with thousand of devices on the market I am sure 1 or 2 obscure models do it).

[1] If you have a 1080p Android device with a pixel ratio of 3.0 (eg. Nexus 5, LG G2, Galaxy S4, HTC One M7, etc), you can simulate the downsampling of the iPhone 6+ by zooming out in your browser by a factor of 360/414 = 0.8696

Edit: I did NOT downvote you. I agree that for many apps it won't be noticeable, but it will be in some apps. Many users spend a lot of time in the browser, and many sites use 1px lines, and they will be a distracting artifact (unless Apple implemented a special hack to interpolate 1px lines in the browser - maybe Safari bypasses downsampling and forcibly rounds them up to 3 physical pixels, but then what about other browsers?)

[nailer]

Why wouldn't a 1px CSS line, shown with 3 pixels on iPhone 6+ per, downsampled to HD (per the article) still look OK?

[runeks]

FWIW, here's how a 1 pixel line looks on my Nexus 5 (4.95" 1080p display): http://i.imgur.com/RmRHpit.png

Here's the web page with the 1 pixel line: http://jsfiddle.net/k0xep8pL/embedded/result/

On my PC, the line is just a single pixel. On my Nexus 5 -- as you can see -- it's actually three lines, which are (from top to bottom): grey (RGB=134), black (RGB=0), grey (RGB=156).

The impression I get, when looking at it on my phone, is a solid black line. Bear in mind, that the width of the display is 61 millimeters, which means that these three pixels take up only 0.17 millimeters on the screen.

[pfranz]

I think the reason raster icons have stuck around so long is the proportions of icons need to change as the scale gets really small to keep them recognizable (I think formats like svg has support for this now). Any vector icons also need to be rasterized before drawing to the screen which can take up memory and make things less speedy.

Vector icons were the new hot well before the original iPhone was released. Here's an article about OSX 10.4 Tiger released in 2004, 3 years before the first iPhone[1].

[1] http://forums.appleinsider.com/t/45544/mac-os-x-tiger-to-sup...

[mpweiher]

> Any vector icons also need to be rasterized before drawing to the screen which can take up memory and make things less speedy.

Well...any raster format needs to be read from disk, decoded and drawn, though there are special optimizations for the drawing step.

[pfranz]

...any vector format needs to be read from disk, decoded and "rendered" (bezier, gradients, transparency, etc calculated), too.

[cageface]

You can use PDF assets in iOS 8 instead of bitmaps but the tools haven't completely caught up with this yet.

[mpweiher]

> Since the points are rendered in pixel-perfect form and then down sampled on the iPhone 6+, the only potential loss of fidelity is in the downsampling step.

Are we sure that this is how it's implemented? They could just as well have the frame buffer be 1080p and adjust the device matrix of the rendering engine(s).

> but we should have moved to SVG or some vector format as a native format in iOS several years ago.

Like PDF?

[josho]

I wonder if Apple's ios7/Yosemite icon designs are a shift in this direction to vectors. E.g. the icons look like they are authored as a vector. But, I wonder if the platform APIs are not yet ready to handle vectors everywhere and seamlessly between pixel/vector formats.

[seanmcdirmid]

Almost all of these are done as vectors in Illustrator and pre rasterized into pixels (with touch ups in PS if necessary).

[bennyg]

Absolutely. No designer worth their salt is starting with PS for these app icons.

[smackfu]

OTOH, iOS 7 did a fine job of almost entirely removing bitmaps from iOS in advance of these new screens. So developers are in a lot better shape now than if they had to redraw all their skeumorphic assets at 3x.

[ntaso]

Since there was never an iOS update that did NOT break my app in some way or another, I don't expect resolution hell to work out of the box. Android had to deal with this for years and matured. In iOS, the last release of my iPhone app asked me to upload a gazillion different pixel-perfect icon sizes.

I have a small online business. I have neither time nor patience to do this shit myself, but it'd probably take one person for the app only to maintain it properly through all these nasty upgrades all the time. Oh, and this person now needs at least 4 different iPhones to test that stuff properly.

Good for you that you were the Android guy. I'm the guy required to have an Android guy and an iOS guy. Which sucks ;)

[BugBrother]

Just out of curiosity... you need four different iPhones to test?

How many different O/S and model variants do you need, to feel safe on Android? Or does your app not do anything complex with the graphics?

[ntaso]

Well, the iOS simulator so far wasn't really that good. There were some minor parts that didn't work in the simulator, but they worked on the iPhone. I used to test with two different iPhones: 4 and 5.

My Android-app is a lot less complex. The visually complex part (a custom chart that cannot be done with a default charting library) wasn't implemented in the Android-app.

We're working on a new version. I plan to test it on probably 3-4 devices as well, but with the assumption that Android is far better at handling different screen sizes than iOS currently (because maturity).

So yes, in the end, I'll have to test on 4 different devices for both platforms. With Android, I can mostly borrow devices from friends. Not so with iPhones. I might skip on the large iPhone 6 though. It's just too ugly to care about ;)

[happyscrappy]

Android developers have to take what ever comfort they can get, it certainly won't be the money.