>> [MUSIC PLAYING]
>> ZAMYLA CHAN: Let's blow things up with resize.
In resize, the user will pass in, via the command line, a bitmap image that
they want you to scale by a number that they also pass in,
in the command line.
How do we do this?
>> Well, first things first, let's break this down into steps.
You're going to want to open the infile that they give you, as well as
create and open the outfile that you're going to put the
resized image in.
Then, because you're resizing, and because it's a bitmap, it a header, so
you're going to also update the header information for the outfile,
and write that in.
Then, you're going to read into the scanline of the infile,
pixel-by-pixel, resizing horizontally and writing those pixels into the
outfile, as specified by the user's scale.
>> You're going to remember to add padding as necessary.
More on that later.
And then, also resize vertically.
OK.
So this is going to be a little bit more complicated than Who Done It, but
what's similar is that copy.c will, again, prove very useful.
Remember that copy.c opens a file, updates the header information for the
outfile, then reads into the scanline, pixel-by-pixel, writing every pixel
into the output file's scanline.
>> So again, your first step might probably be to cp, copy.c, resize.c
into your PSET5 directory.
Remember though, before you copy it, to make sure that you understand
copy.c very thoroughly.
OK.
>> So let's open a file.
You know how to do that.
I'm going to leave that to you.
Next, update the header information for the outfile.
Because we have a new bitmap, we have new header info.
What's changing here?
Well, the file size is going to change because we're going to have more
pixels than before.
The image size is, thus, also going to change, as is the
width and the height.
>> So which variables are those, exactly?
Well, if you look into the header information, you see there is
biSizeImage, which represents the total size of the image in bytes,
including pixels and padding.
biWidth is the width of the image in pixels, minus the padding.
biHeight is the height of the image in pixels.
And so those are contained in the structs BITMAPFILEHEADER and
BITMAPINFOHEADER.
You can tell which one is which by going to bmp.h and looking at the
BITMAPINFOHEADER struct and seeing which variables are listed there.
>> So to update the outfiles header information, you're going to want to
change those values of the height and the width.
But chances are, you might need some of the infile's header information
later, so best to keep track of both.
But be very clear with your variable names so that you don't accidentally
write the incorrect values in the header for the outfile.
>> So now let's get to reading into the scanline pixel-by-pixel.
Again, we're going to turn to our trusty file I/O library, and look at
the fread function.
fread takes in a pointer to a struct that will contain the bytes that
you're reading in, the size of each element that you're reading--
again, sizeof is going to be useful function here, the number of the
elements of size, size, that you're reading in, and then finally, the
inpointer, the file that you're reading from.
So you're taking number elements of size from inpointer, and
putting them into data.
>> Now it's time to resize horizontally.
if n equals 2, then for each pixel in the infile, we're going to write it
twice in the outfile.
How do we write files?
Well, we have the fwrite function, so we've taken the pointer to the struct
that contains the bytes that you're writing from, and then we pass in
size, number, and the output, where you're going to be writing that.
And then to repeat a process, will be able a simple iterative for loop.
>> But we need to remember to add padding in.
The concept of padding is that, well, each pixel is three bites, but the
size of each scanline must be a multiple of 4 bytes.
So if the number of pixels isn't a multiple of 4, we need to add some
padding, which is just zeroes.
Now, unlike Who Done It, and unlike copy, then infile image and the
outfile file have different have different padding because they're
different widths.
>> OK.
So perhaps a formula would come in handy here.
I'll leave it to you to find it out, but tell you that, to write padding,
well, it's just a simple fputc function, passing in the character
that you want to write, and then the file pointer that you
want to write to.
So now that we've resized horizontally, and then used padding,
remember that you need to move your file position indicator, because you
can't fread into padding.
So you want to make sure that your file position indicator in the infile
is at the correct point.
Because we also want to resize vertically.
We can't just stretch it horizontally, because every row needs
to be copied n times.
>> Now, there are several different ways to do this.
So one, we can use a rewrite method, in that we remember all of the pixels
of a given row in an array, and then we write that array as
many times as needed.
Or there's the recopy method where, after reading in one row in the infile
and then writing that into the outfile, adding the padding, we fseek
back to the start of the original row, and then repeat the horizontal
resizing from there.
Regardless of the method, though, you'll want every pixel to be repeated
n times, and every row to be repeated n times as well.
>> With that, you'll have bitmap larger than life.
My name is Zamyla, and this is CS50.