pngsmall.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file pngsmall.cpp
///
/// This is a small utility program which decreases in size a PNG file
/// (if necessary) in order to make it fit within the given size.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////
 
// Copyright (C) 1997-2014 by Pawel Pilarczyk.
//
// This file is part of my research software package. This is free software:
// you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// This software is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this software; see the file "license.txt". If not,
// please, see <https://www.gnu.org/licenses/>.
 
// Started on April 10, 2008. Last revision: April 10, 2008.
 
 
// include some standard C++ header files
#include <exception>
#include <cstring>
#include <cstdio>
 
// include selected header files from the CHomP library
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/system/timeused.h"
#include "chomp/system/arg.h"
 
// include local header files
#include "pngimage.h"
 
 
// --------------------------------------------------
// -------------------- OVERTURE --------------------
// --------------------------------------------------
 
/// The title of the program which is displayed every time
/// the program is launched.
const char *title = "\
PNGSMALL, ver. 0.01, 04/10/08. Copyright (C) 1997-2014 by Pawel Pilarczyk.\n\
This is free software. No warranty. Consult 'license.txt' for details.";
 
/// The help information about the program which is displayed
/// if the program is launched without command-line arguments
/// or with incorrect arguments.
const char *helpinfo = "\
This program reads a given PNG image and writes another PNG image\n\
which is the original one scaled down so that the provided width\n\
and height are not exceeded. The down-scaling factors are limited\n\
to the integer numbers for optimal efficiency. The colors of output\n\
pixels are computed by means of an arithmetic average of the input ones.\n\
Command line arguments:\n\
input.png - the name of the input PNG image file to be down-scaled,\n\
output.png - the name of the output PNG file (rewrites the input if none),\n\
-w width - the maximal allowed width of the output PNG image,\n\
-h height - the maximal allowed height of the output PNG image,\n\
-s scaling - the downscaling factor (overrides max width/height settings),\n\
--quiet - makes the program run quietly, without any output messages,\n\
--help - shows this brief help information on the program's usage.\n\
For more information consult the accompanying documentation (if available)\n\
or ask the program's author at http://www.PawelPilarczyk.com/.";
 
 
// --------------------------------------------------
// -------------------- PNGSMALL --------------------
// --------------------------------------------------
 
/// The main function of the program "pngsmall".
/// This function downscales the given PNG image and saves the result
/// as another PNG image.
/// The scaling factor is determined on the basis of the provided maximal
/// allowed width and/or height of the image, unless specified explicitly.
/// Returns 0, or throws an error message in case of failure.
int pngSmall (const char *inName, const char *outName,
        int maxWidth, int maxHeight, int scalingFactor)
{
        using chomp::homology::sout;
 
        // read the input PNG image
        PngImage inPng (inName);
        int inWidth = inPng. width ();
        int inHeight = inPng. height ();
 
        // determine the scaling factor if necessary
        if (scalingFactor <= 0)
        {
                int widthFactor = 0;
                if (maxWidth > 0)
                {
                        widthFactor = (inWidth + maxWidth - 1) / maxWidth;
                }
                int heightFactor = 0;
                if (maxHeight > 0)
                {
                        heightFactor = (inHeight + maxHeight - 1) /
                                maxHeight;
                }
                scalingFactor = (widthFactor < heightFactor) ?
                        heightFactor : widthFactor;
                if (scalingFactor <= 0)
                        scalingFactor = 1;
        }
 
        // if the scaling factor equals 1 then just copy the PNG file
        if (scalingFactor == 1)
        {
                using namespace std;
                if (!outName || !strcmp (inName, outName))
                {
                        sout << inWidth << " x " << inHeight <<
                                ": No downscaling necessary. "
                                "Leaving the file intact.\n";
                        return 0;
                }
                sout << inWidth << " x " << inHeight <<
                        ": No downscaling necessary. "
                        "Copying the file byte-for-byte.\n";
                FILE *inFile = fopen (inName, "rb");
                FILE *outFile = fopen (outName, "wb");
                int ch = getc (inFile);
                while (ch != EOF)
                {
                        putc (ch, outFile);
                        ch = getc (inFile);
                }
                fclose (outFile);
                fclose (inFile);
                return 0;
        }
 
        // create a new PNG image in the memory
        int outWidth = inWidth / scalingFactor;
        if (outWidth <= 0)
                outWidth = 1;
        int outHeight = inHeight / scalingFactor;
        if (outHeight <= 0)
                outHeight = 1;
        PngImage outPng (outWidth, outHeight);
 
        // show the information on rescaling
        sout << "Downscaling " << inName;
        if (outName)
                sout << " -> " << outName;
        sout << ":\n" << inWidth << " x " << inHeight << " -> " <<
                outWidth << " x " << outHeight << " (" << scalingFactor <<
                " times smaller).\n";
 
        // compute the pixels of the new PNG image as averages
        for (int outX = 0; outX < outWidth; ++ outX)
        {
                for (int outY = 0; outY < outHeight; ++ outY)
                {
                        // prepare variables to sum color components
                        int red = 0;
                        int green = 0;
                        int blue = 0;
 
                        // compute the sum of color components
                        int inX = outX * scalingFactor;
                        int inY = outY * scalingFactor;
                        for (int x = 0; x < scalingFactor; ++ x)
                        {
                                for (int y = 0; y < scalingFactor; ++ y)
                                {
                                        int color = inPng. getPixel
                                                (inX + x, inY + y);
                                        red += (color >> 16) & 0xFF;
                                        green += (color >> 8) & 0xFF;
                                        blue += color & 0xFF;
                                }
                        }
 
                        // compute the average of the color components
                        int n = scalingFactor * scalingFactor;
                        red = (red + (n >> 1)) / n;
                        green = (green + (n >> 1)) / n;
                        blue = (blue + (n >> 1)) / n;
 
                        // plot the pixel with the average colors
                        int color = (red << 16) | (green << 8) | blue;
                        outPng. putPixel (outX, outY, color);
                }
        }       
 
        // save the output PNG image to a file
        outPng. save (outName ? outName : inName);
        return 0;
} /* pngSmall */
 
 
// --------------------------------------------------
// ---------------------- MAIN ----------------------
// --------------------------------------------------
 
/// The main procedure of the program.
/// Returns: 0 = Ok, -1 = Error, 1 = Help displayed, 2 = Wrong arguments.
int main (int argc, char *argv [])
{
        using namespace chomp::homology;
 
        // prepare user-configurable data
        char *inName = 0;
        char *outName = 0;
        int maxWidth = 0;
        int maxHeight = 0;
        int scalingFactor = 0;
 
        // interprete the command-line arguments
        arguments a;
        arg (a, 0, inName);
        arg (a, 0, outName);
        arg (a, "w", maxWidth);
        arg (a, "h", maxHeight);
        arg (a, "s", scalingFactor);
        arghelp (a);
 
        argstreamprepare (a);
        int argresult = a. analyze (argc, argv);
        argstreamset ();
 
        // if no input name has been provided then show the help information
        if (!inName)
                argresult = 1;
 
        // show the program's main title
        if (argresult >= 0)
                sout << title << '\n';
 
        // if something was incorrect, show an additional message and exit
        if (argresult < 0)
        {
                sout << "Call with '--help' for help.\n";
                return 2;
        }
 
        // if help requested, show help information
        if (argresult > 0)
        {
                sout << helpinfo << '\n';
                return 1;
        }
 
        // try running the main function and catch an error message if thrown
        try
        {
                // set an appropriate program time message
                program_time = "Aborted after:";
                program_time = 1;
 
                // run the conversion procedure
                pngSmall (inName, outName, maxWidth, maxHeight,
                        scalingFactor);
 
                // set an appropriate program time message
                program_time = "Total time used:";
 
                // finalize
                return 0;
        }
        catch (const char *msg)
        {
                sout << "ERROR: " << msg << '\n';
                return -1;
        }
        catch (const std::exception &e)
        {
                sout << "ERROR: " << e. what () << '\n';
                return -1;
        }
        catch (...)
        {
                sout << "ABORT: An unknown error occurred.\n";
                return -1;
        }
} /* main */