pset4 won't resize vertically

Question

I've managed to get my code to work for resizing the image horizontally, but I'm not sure why it doesn't seem to resize the image vertically

    // Copies a BMP file

    #include <stdio.h>
    #include <stdlib.h>
    #include "bmp.h"

    int main(int argc, char *argv[])
    {
        // ensure proper usage
        // I changed to argc eqal to four because it will be accepting
        // the name of the program, the number we want to increase the size by,
        if (argc != 4)
        {
            fprintf(stderr, "Usage: copy infile outfile\n");
            return 1;
        }

        // remember filenames
        int n = atoi(argv[1]);
        char *infile = argv[2];
        char *outfile = argv[3];
        // I'm going to need to change this and add something about what
        // var resize is, as well as convert var resize from
        // an array of characters to an integer

        // open input file
        FILE *inptr = fopen(infile, "r");
        if (inptr == NULL)
        {
            fprintf(stderr, "Could not open %s.\n", infile);
            return 2;
        }

        // open output file
        FILE *outptr = fopen(outfile, "w");
        if (outptr == NULL)
        {
            fclose(inptr);
            fprintf(stderr, "Could not create %s.\n", outfile);
            return 3;
        }

        // read infile's BITMAPFILEHEADER
        BITMAPFILEHEADER bf;

        fread(&bf, sizeof(BITMAPFILEHEADER), 1, inptr);



        // read infile's BITMAPINFOHEADER
        BITMAPINFOHEADER bi;
        fread(&bi, sizeof(BITMAPINFOHEADER), 1, inptr);

        // ensure infile is (likely) a 24-bit uncompressed BMP 4.0
        if (bf.bfType != 0x4d42 || bf.bfOffBits != 54 || bi.biSize != 40 ||
            bi.biBitCount != 24 || bi.biCompression != 0)
        {
            fclose(outptr);
            fclose(inptr);
            fprintf(stderr, "Unsupported file format.\n");
            return 4;
        }

        bi.biWidth *= n;
        bi.biHeight *= n;
        int padding2 = (4 - (bi.biWidth * n * sizeof(RGBTRIPLE)) % 4) % 4;
        //keep in mind i'll need to change the padding
        //probably best to declare it as a variable earlier

        bi.biSizeImage = ((sizeof(RGBTRIPLE) * bi.biWidth * n) + padding2) * abs(bi.biHeight) * n;

        // write outfile's BITMAPFILEHEADER

        fwrite(&bf, sizeof(BITMAPFILEHEADER), 1, outptr);

        // write outfile's BITMAPINFOHEADER
        fwrite(&bi, sizeof(BITMAPINFOHEADER), 1, outptr);

        // determine padding for scanlines
        int padding = (4 - (bi.biWidth * sizeof(RGBTRIPLE)) % 4) % 4;
        // I should declare a seperate padding above
        // iterate over infile's scanlines
        for (int i = 0, biHeight = abs(bi.biHeight); i < biHeight; i++)
        {
            for (int b=0; b < n; b++)
            {
            // iterate over pixels in scanline
                for (int j = 0; j < bi.biWidth; j++)
                {

                    // temporary storage
                    RGBTRIPLE triple;

                        // read RGB triple from infile
                        fread(&triple, sizeof(RGBTRIPLE), 1, inptr);

                            for (int a=0; a < n; a++)

                        // write RGB triple to outfile
                        fwrite(&triple, sizeof(RGBTRIPLE), 1, outptr);
                }
                fseek(inptr, - (sizeof(RGBTRIPLE) * bi.biWidth *n), SEEK_CUR);
            }
            for (int k = 0; k < padding2; k++)
            {
                fputc(0x00, outptr);
            }
        fseek(inptr, padding, SEEK_CUR);
        }
        // close infile
        fclose(inptr);

        // close outfile
        fclose(outptr);

        // success
        return 0;
    }

Thanks for reading the question

Answer 1

There are several issues in the code that need to be addressed. They're affecting both horizontal and vertical scaling when n != 1.

Many of the problems are centered around bi.width and bi.height. The code multiplies both by n, but then uses the new values where the original values are needed, such as controlling the reads and repositioning in the input file.

When the coding for something like this is too confusing, and the memory overhead needed is small, it's better to just create a second set of vars. In this case, you could either create two new vars, say bi2width and bi2height, or create two complete new headers, bi2 and bf2.

There are more issues, but because these are so significant, I suggest fixing these first. These issues could be both masking and creating other problems, which may disappear, depending on what you change. Once you work through this, if you still can't make progress, then post a new question.

If this answers your question, please click on the check mark to accept. Let's keep up on forum maintenance. ;-)