I'm creating a data storage device that takes a certain number of pictures of the night sky over a couple of hours, and the pictures will be downloaded right after they are all taken. The memory card must be able to store all of the pictures at once.

The JPEGs that will be taken are 640x480 pixels, and it is essential that there is enough room on the memory card for all 100 of them. So what is the largest size of a 640x480 JPEG?

I have taken some test pictures to figure this out:

The file size of the "stackoverflow" image is 73,774 bytes.

The file size of the white image is only 36,607 bytes.

But the file size for the checkered photo clocks in at 149,339 bytes.

I am assuming that the file size increases with complexity.

How can I build enough room on the memory card to fit 100 640x480 JPEGS, without knowing how complicated and what size they will be? I don't want to waste extra space as I may be making many of these capture devices.

it depends on the image producer. 100-quality JPEG can easily blow up in size. What is your camera and camera settings?
–
Jan DvorakAug 25 '13 at 4:22

The test camera is a Canon Powershot A1100 IS. For more info, you can check the metadata, because I'm not sure what you are asking for.
–
Blue IceAug 25 '13 at 4:25

1

HAve you taken any sample pictures of the night sky at dif. Q settings? As a test?
–
Carl BAug 25 '13 at 4:59

2

What is this for? Are you sure jpeg is the right choice of format.
–
Jack AidleyAug 25 '13 at 7:55

3

The add some background to Jack Aidleys comment: JPEG compression changes the picture. It makes assumptions and discards information in order to get a smaller file size. (Unless set to 100% quality, in which case you might as well use an uncompressed format. Often a digital camera has a tiff or even a raw setting for this. If you want to keep all small dots such as stars then use one of these). This will also make the size of an image completely predictable.
–
HennesAug 25 '13 at 9:57

2 Answers
2

Here I suggest an upper bound for JPEG file sizes. See Ilmari Karonen's answer for a discussion of more typical jpeg sizes.

The pixel storage space for a 640X480 32-bit bitmap image can be calculated like so (based on this answer, but corrected based on Ignacio Vazquez-Abrams' comment and this answer):

Assuming that no compression has been applied to the file, there are
307,200 pixels, which is a 0.3MP. Handy look up table

If each pixel contains 32 bits of information,
then

307,200 * 32 = 9,830,400 bits of information

Divide by the 8 bits to become a byte value

9,830,400 / 8 = 1228800 bytes (Or 1.17 Mb)

This is the size of an uncompressed bitmap, and as such should be an upper bound for jpeg file size (In reality, because the JPEG format uses compression, your images should be much smaller, especially given that you're taking pictures of the night sky, which I imagine contains a lot of black. Note that the largest example image in your question is only 0.14 MB).

With regard to your specific issue however, even using that upper bound, 100 images is only 117 MB, and it's been a long time since I've seen a memory card as small as 128 MB. I suspect any currently available memory card will have enough capacity to meet your needs.

Apparently the issue of maximum jpeg file size is subject to some debate. This Stack Overflow answer suggests a theoretical maximum size of 20.25 bytes per pixel, or 5.9 MB in your case, but producing an image of that size requires deliberate misuse of the jpeg format's compression scheme, so it's extremely unlikely that you'd ever see such a thing produced by a camera.

Thanks @IgnacioVazquez-Abrams. That's what I get for assuming an accepted answer is correct.
–
ForeverWintrAug 25 '13 at 6:11

1

@IgnacioVazquez-Abrams - "Alignment" is an attribute dictated by the processor (not the storage medium), and is convenient when the data is in RAM for processing. For storage purposes, a 32-bit word alignment is not a necessity and certainly an extravagance. Packing data is a common operation prior to writing to storage, especially for a certain 25% savings. I've seen digital cameras that store each pixel in exactly 3 bytes for the raw format.
–
sawdustAug 25 '13 at 6:15

1

"... certainly an extravagance." Nowadays. Many moons ago it used to be considered a cycle-saving feature (no need to align on load, given how long it would take).
–
Ignacio Vazquez-AbramsAug 25 '13 at 7:59

3

In practice, while some systems might store RGB image data as 4 bytes per pixel in memory, pretty much all image file formats use 3 bytes per pixel at most (unless there's an actual alpha channel stored in the fourth byte). See my answer below.
–
Ilmari KaronenAug 25 '13 at 12:56

OK, so the uncompressed PPM file is 640 × 480 × 3 = 921,600 bytes long, plus 15 bytes for the minimal PPM header, just as expected. Trying to losslessly compress it using the PNG format just ends up increasing the size by 2157 bytes, presumably taken up by PNG headers and metadata and possibly some slight inefficiency in the compression algorithm trying to compress incompressible data.

(Yes, that's 3 bytes per pixel, not 4; even the PPM format, which is about as simple as a graphics file format can get, isn't dumb enough to store a useless fourth byte per pixel on disk. There may be some advantage to doing so in memory for alignment reasons, especially if you also need to store an alpha channel, but those reasons don't apply when writing the image to a file.)

OK, so what about JPEG? Let's try to minimize the compression losses first (quality = 100, no chroma subsampling, floating-point DCT). Unfortunately, the pnmtojpeg manual doesn't clearly explain how to set all the relevant options (specifically, the -sample option is listed in the "Options for wizards" section, which just references a file in the libjpeg documentation), so I'll convert it in the GIMP instead. The resulting file looks like this:

What, how can it be smaller? Didn't I just say pure noise was incompressible? Well, the thing is, even at maximum quality, normal JPEG compression isn't quite lossless. Reopening the image in GIMP and comparing it with the original, one can see that some pixels have had their color values shifted by one or two steps (out of 256). Those are the pixels where the JPEG compression algorithm "cheated" and threw away a bit here, another there, where it estimated that the change wouldn't be noticeable. Indeed, to the unaided human eye the result is quite indistinguishable from the original, but those discarded bits do add up to a measurable decrease in file size, even after accounting for header and encoding overhead.

So that was maximum quality; what about more typical settings, like the pnmtojpeg defaults (quality = 75, subsampling enabled)? Let's try it:

$ pnmtojpeg < rnd.ppm > rnd2.jpg
$ du -b rnd2.jpg
185128 rnd2.jpg

(JPEG compressed RGB noise, quality = 75, chroma subsampling, 184 kb)

Wow, from 901 down to 184 kb! That's pretty aggressive compression, though, and you can definitely tell the difference when comparing the images closely. Most of it's because of the chroma subsampling, which basically just throws away 75% of the color (hue / saturation) data. Trying it in the GIMP with subsampling disabled gives a 350,618 byte file that still looks (to the human eye, at least) pretty close to the original even when magnified.

Anyway, the point of all this is to demonstrate that, no matter how noisy your night sky photos might be, and no matter how high a quality you might select, there's just no way a 640 × 480 JPEG file can get significantly larger than 900 kb. (Well, unless your camera attached a multi-megabyte Exif color profile to it or something equally stupid, that is.) And if you're using more typical JPEG compression settings, the maximum plausible file size goes down to about 200 kb or so.

@DanielBeck: Right. Obviously, you can compress any data as much as you want if you're willing to just throw away parts of it. (That's basically what JPEG compression does, it just tries to do it in such a way that the lost parts are not noticeable to the human eye, and that what remains can be encoded compactly. Noise is still a tough case for it, since the only thing even a lossy compression algorithm can do with noise is throw away parts of it.)
–
Ilmari KaronenAug 25 '13 at 14:13

Maybe that's just me, but the second image looks brighter than the first one.
–
BogdacutuAug 25 '13 at 16:12

@Bogdacutu: It shouldn't, although it's always possible that your browser may be doing something weird with color management etc. Try loading them both in a graphics editor and comparing the color values.
–
Ilmari KaronenAug 25 '13 at 16:17