PixInsight > Wish List

Support for Retina Display in new Macbook Pros

(1/4) > >>

siovene:
Hi,
yesterday at WWDC Apple announced the new Macbook Pros with a Retina Display: the resolution is 2880x1800 pixels.

Applications that are not ported to the new resolution will appear with pixels binned 2x2.

However, it could be great if PI could be ported to the new system, so that users on OSX could take advantage of that large DPI amount.

Juan Conejero:
The Mac OS X version of PixInsight is a Cocoa application, so in theory it should not have too many problems. This is just in theory, but in practice, adapting PI to retina displays will require a huge amount of work.

On one hand, all tool bar and tool button icons are currently 16x16 pixels in PixInsight. This size is very appropriate for resolutions up to full HD (1920x1080). I am writing this post on my Linux workstation with a 27" monitor at 2560x1440. At this resolution, PI icons are still usable, but are very close to the limit. At higher resolutions they are clearly too small, and they will be completely useless on a new generation iMac, for example. This means that *all* icons in PixInsight will have to be redesigned and drawn from scratch. And there are quite a bunch of them... this may require a complete year of non-dedicated work, perhaps more, especially considering that the guy who has to redesign and draw them is... well, you are reading him right now. And no, we don't have the resources required to pay for this work.

On the other hand, PixInsight depends on Qt. Qt is Cocoa-native on Mac OS X, and finally, since Qt 4.8, it seems that we have not too many Qt/Cocoa bugs on Mac OS X (just a bunch of them that I have under control, for now, and a few that I still have to fix). So again, in theory, there are no problems. But PixInsight is not a simple Mac application. It is a complex multiplatform application with three integrated UIs, a modular architecture that is quite similar to an operating system, and lots of customized controls and custom behaviors that are completely alien in the wonderful and exquisite world of Mac OS X.

Keeping PI working and looking reasonably well on Mac OS X requires a lot of hard work. I am getting really sick of rendering problems on Mac OS X (also on Windows, to a much lesser extent), so I have made a breaking change for PI 1.8: Do not use native controls, but custom controls that are and behave exactly the same, pixel by pixel, on all platforms. I have this work already done, and it is in fact very nice and works great. Finally, PI is pixel-perfect on all platforms and everything works predictably. PCL and script developers no longer will have to write special code for the Windows and Mac versions of their products.

However, the new GUI in PI 1.8 is based on Qt style sheets and custom controls. I don't know if this will generate new problems with retina displays and their associated high resolution modes on Mac OS X. In theory, if text is properly scaled in terms of DPI, there should be no problems, but again, the new PI GUI depends on custom bitmaps and images that may be hard to see or fuzzy at the new modes. I don't know; I have to make lots of tests, and I also need new hardware. Frankly, I am reluctant to spend 2,500 EUR or more in a slow laptop machine that I don't need and won't use because I'll have to see it with a microscope, just to check if "things look nice".

So, don't hold your breath. We have many important things to do besides retina display compatibility on the Mac: New and exciting image processing tools, new development tools, and a much more powerful and stable core application.

rwodaski:
It looks to me like apps that implement support for the Retina display actually support two resolutions. The app itself operates at the user-selected desktop resolution, which at this point is always lower than the pure retina max resolution. However, the image-editing portion of the app has access to the full retina resolution. So icons and such would still be at a reasonable resolution, but the images are full-resolution.

I tested this is iPhoto and Aperture (all that was available with Retina support on the MBP in the local Apple Store), and it's an excellent way to support high resolution: only where it's actually useful. This is far different from, say, what one would deal with on a 30" Apple Cinema display, where everything is operating at high resolution (and would be subject to some of the issues you mention). This is basically a 'best of both worlds' approach to the problem. The UI is at one (readable) resolution, and the data is at full resolution. I would expect we'll see expansion of this concept across the Apple line, and of course all good things get stolen so perhaps we'll see it in other operating systems as well. It's an interesting and, to my eye, positive way to deal with both increasing pixel counts and decreasing pixel size.

I would also add that retina support is more than just a pretty feature; the ability to see an image at 100% in retina resolution is spectacular, but the ability to see very large images all at once on the screen at 100% resolution is a major good thing for evaluating the state of an image. Right now, I use Pixinsight on large monitors most of the time, and the advantage of being able to view all the data is wonderful. Makes me hate working with PI on the smaller laptop screen.

I would encourage you to look further at the way that Retina is implemented; it may turn out to be quite useful as a concept to support the UI and the data at different resolutions. If the OS handles this neatly, then you don't even have to worry about a new generation of icons. <g>

Josh Lake:
This is great to hear, Ron, and thanks for all the hard work, Juan. I'm actually getting one of these 15" MBP with Retina (owned by my school, I can't shell out that kind of money!). I'd be happy to test for you as soon as I get it.

I guess the view controls are nicely adjustable, too:

Juan Conejero:
Hi Ron,

Unfortunately, that's only what seems to happen when you look at an application working on the new Retina displays. Actually, things are not so easy from the development side.

Basically, an application can be high resolution capable or not. If it isn't, then OS X runs it in magnified mode. In this mode, OS X automatically scales the application 2:1 in real time using nearest neighbor interpolation (which is bad but not as horrible as it sounds). The result is that everything in the application's GUI---including images---looks rough and fuzzy, especially when compared side-by-side to high resolution capable applications. These applications are second-class citizens in the shiny OS X world, something that we obviously don't want to be.

Being high resolution capable is pretty easy for a Cocoa-based application like PI: just tell OS X that your application can work in high resolution mode, and it will trust you. However, the user has to be able to see and point to all the elements of the application's GUI, and this requires high-resolution versions of all bitmaps, icons and custom controls. For a complex multiplatform application like PixInsight, where all controls are customized, this means a lot of work, including a complete redesign of internal resource management routines (being a 100% portable application, PI doesn't rely on any OS-specific resource management system). There are other problems related to fonts and control sizes, but these are easier to solve.

You're right that the images will look spectacular at very high resolutions. The good news in this case is that we don't need to do anything at all: all image windows will draw their contents at the native resolution of the display.

Navigation

[0] Message Index

[#] Next page