I have a table view that displays custom cells with an image of the item. I allow the user to choose a photo from there library, which will be displayed on the cell. The image is saved in the documents directory.
I am confused on how to handle the retina vs non-retina displays.
Let's say my image is 70 x 70 pixels, should I also keep a 140 x 140 pixel version for the retina display. What's an appropriate way to handle this situation?
Yes, you should have a 70x70 px file and a 140x140 px one also. If you name your normal image "CellImage.png", you should name the retina one "CellImage#2x.png".
If you are allowing the user to choose the image from their library I am assuming that you are resizing the image before placing it in the Documents directory.
If you are sure that the images will not be shared between different devices (as in iCloud) then you can simply save the image in the correct scale and forget about it. i.e. scale the image appropriately for the current device.
You could just save the image at 140x140 and have the presentation properly scaled by the size constraints of theUIImageView.
I don't know if imageWithContentsOfFile works the same way as imageNamed method or not but when calling the imageNamed method you don't specify the file's extension but rather just the bare filename and the method attempts to select the correct file without you having to specify the decorations i.e.
Image.png
Image#2x.png
Image~iphone.png
Image#2x~iphone.png
Related
When applying Retina 4 for the storyboard, it would give a resolution of 320points-by-480points which is 640-by-960 in pixels.
However, when adding an image for an UIView or an UIButton by dragging it from the Media library into the VC, [not programmatically]
let's say, the image has a resolution of 50-by-50 in pixels,
instead of appearing 25points-by-25points in the storyboard,
it would appear 50points-by-50points.
Is it possible to set the the conversion from pixel to point to be triggered automatically instead of having to compress the image to half later on?
Yes - the image filename must have #2x at the end, so interface builder knows it is a retina asset. You should also include a non- retina version with the plain filename.
I would like to have images for my UIButtons, screen background etc in my iPhone app.
Will it work for both Retina display and normal display if I have
ButtonImage.png and ButtonImage#2x.png
Background.png and Background#2x.png
OR, should I do any extra coding so that it works for both displays?
ButtonImage.png is looking awkward on Retina Simulator. So, I should have a higher resolution image. So... please help me.
Chandu
UIImage's imageNamed: method automatically looks up the #2x images on the retina device if they're available; no additional coding is required.
If you’re putting the image in your user interface in a .xib file, or if you use the +imageNamed: class method for UIImage, then the #2x suffix is sufficient to load Retina images.
you have nothing to do, ios do the job to choose the right one
Short Answer: Yes, that is the right way to do what you want. UIImage will figure it all out for you.
However, don't forget that you can't just copy and rename a given image (say, Background.png). You need to get an image that is the same as Background.png, but four times the resolution (that's the same as double the width and double the height). Then, you can name that Background#2x.png and everything'll be peachy keen.
Here you have to use the simple image and it will work for both, Normal display as well as retina display. You just specify simple images with ButtonImage.png & Background.png in the resource bundle and retina images ButtonImage#2x.png Background#2x.png in the resource bundle.
Now you just need to specify the simple images in the code and retina image will automatically taken when running on the device with retina screen resolution i.e. iPhone 4 and later.
backgroundImageView.image = [UIImage imageNamed:#"Background.png"];
The same code will work and when iPhone 4 with retina display it will consider the image Background#2x.png from resource bundle automatically.
Let me know if you have any other question.
That's the right thing i mean whatever you are using or describing the way,but second thing
you need to do is that allocating the position for buttons.
If you will allocating position as a constant or fix by declaring x,y coordinate then it might not work,so try to allocate position of button in dynamic way so that it will take position once retina will call it.
Thanks
Beginner here. My app shows an UIImage (in a scroll view).
If you are on retina device, then it should not scroll and I set the scroll view frame to be
the exact size (640x960).
If you are not on a retina device then it should scroll, so I set the scroll view frame to the pixels (480x320).
I have this working by setting the frame sizes, as mentioned, in viewDidLoad()
So...my question is that I have to keep both images on disk. I have pix.png and pix#2x.png and they are exactly the same thing.
Any help on how to handle this? Maybe it is obvious, but not to me ;-)
thx!
In my opinion,If you load the image with the two file name, I think you should keep them on disk.If not, you can delete one of them. Nomatter what pixels size you set, the original pixels datas are always which image file you load from disk.
No, you shouldn't need two copies of the same image. The #2x scheme is just lets you automatically load a high resolution image when one is available. It sounds like you're already managing your scroll view's content size and things are working, so you can just get rid of the pix#2x.png file.
I'm not sure it's a great UI decision to change the app's behavior based on its screen resolution, though. Since you're already using a scroll view, it can be easy for the user to zoom in and out. Non-retina devices will display at native resolution when zoomed in; retina devices will display at native resolution when zoomed out.
I am creating an app that has images in a picker view, but I have noticed that these images appear pixelated. Currently, I have the resolution set at 72 pixels/inch. I have increased it to 300 pixels/inch, but have not noticed a change. Has anyone run into the issue?
If you are creating these images in Photoshop, changing the DPI won't change the image file. A 4x4 image will have 16 pixels. When you change the DPI, it simply changes how large those pixels are on your display. In the case of the retina display, You need to create an image that is double the size (e.g. 8x8).
YOu need to provide the same file as a "#2x" file with double the size. For example, if you have:
myImage.png #32x32
Then you also need:
myImage#2x.png #64x64
When calling the resource, you can use the same way and ignore the #2x part of the filename. IOS will do the right thing. On high density devices, it will choose the bigger file, otherwise it will choose the smaller one.
[UIImage imageNamed:#"myImage.png"]
You dont need the png, but it works with or without it. This code works on all OS's. If it is a retina display, it will use the big image, otherwise not try it.
I'd like to design a background image for my app. The image should fill the iPhone screen.
What image size that will work for 3G and 4G?
A) 320 x 480.
B) 640 x 960.
I prefer to use B as it will have more quality, will 3G resize the image to fit?
Thanks for any help.
Simply author both sizes and save the hi-res with a #2x suffix in the filename (like background.png and background#2x.png). iPhone 4 will use the hi-res image, older devices will stick to the ordinary one. See the docs for +[UIImage imageNamed::
This method looks in the system caches
for an image object with the specified
name and returns that object if it
exists. If a matching image object is
not already in the cache, this method
loads the image data from the
specified file, caches it, and then
returns the resulting object.
On a device running iOS 4 or later,
the behavior is identical if the
device’s screen has a scale of 1.0. If
the screen has a scale of 2.0, this
method first searches for an image
file with the same filename with an
#2x suffix appended to it. For
example, if the file’s name is button,
it first searches for button#2x. If it
finds a 2x, it loads that image and
sets the scale property of the
returned UIImage object to 2.0.
Otherwise, it loads the unmodified
filename and sets the scale property
to 1.0. See iOS Application
Programming Guide for more information
on supporting images with different
scale factors.
Also read the appropriate part of iOS Application Programming Guide.
Although it is trivial to resize the image to the proper size, you should prepare both 320×480 and 640×960 (and probably you need a 1024×768 for iPad too). In this way the system can choose the best image for that model.
Basically, you create a 320×480 background.png for the older models, and a 640×960 background#2x.png for retina display. Then load the image with
UIImage* backgroundImage = [UIImage imageNamed:#"background.png"];
in this way, the system will choose the best resolution automatically.