This is imgray.c in view mode; [Download] [Up]
/**
** $Header: /import/dev-vis/image/imtools/v2.0/imtools/src/RCS/imgray.c,v 1.1 91/10/03 13:19:54 nadeau Exp $
** Copyright (c) 1989, 1990 San Diego Supercomputer Center (SDSC)
** San Diego, California, USA
**
** Users and possessors of this source code are hereby granted a
** nonexclusive, royalty-free copyright and design patent license to
** use this code in individual software. License is not granted for
** commercial resale, in whole or in part, without prior written
** permission from SDSC. This source is provided "AS IS" without express
** or implied warranty of any kind.
**
** For further information contact:
** E-Mail: info@sds.sdsc.edu
**
** Surface Mail: Information Center
** San Diego Supercomputer Center
** P.O. Box 85608
** San Diego, CA 92138-5608
** (619) 534-5000
**/
#define HEADER " $Header: /import/dev-vis/image/imtools/v2.0/imtools/src/RCS/imgray.c,v 1.1 91/10/03 13:19:54 nadeau Exp $"
/**
** FILE
** imgray.c - Image File Format Conversion to grayscale
**
** PROJECT
** IM - Image Manipulation Tools
**
** DESCRIPTION
** imgray converts image files to grayscale.
**
** PUBLIC CONTENTS
** d =defined constant
** f =function
** m =defined macro
** t =typedef/struct/union
** v =variable
** ? =other
**
** main f main program
**
** PRIVATE CONTENTS
** toolCommand v tool-specific tool info
** toolHelp v tool-specific help
** toolOptions v tool-specific options
** toolEquivs v tool-specific equivalent keywords
**
** toolInFilename v the name of the input file (could be 'stdin')
** toolOutFilename v the name of the output file (could be 'stdout')
**
** toolInFormat v the name of the input file's format (could be '\0')
** toolOutFormat v the name of the output file's format (could be '\0')
**
** toolInTable v a table for the storage of data read in
** toolFlagsTable v a table for the storage of read/write flags
**
** toolInit f initialize things for the tool
**
** HISTORY
** $Log: imgray.c,v $
** Revision 1.1 91/10/03 13:19:54 nadeau
** Initial revision
**
**/
#include "imtools.h"
extern void toolInit( ); /* Initialize things */
/*
* GLOBALS
* toolCommand - tool-specific tool info
* toolHelp - tool-specific help
* toolOptions - tool-specific options
* toolEquivs - tool-specific equivalent keywords
*
* DESCRIPTION
* toolCommand describes the command to the arg package.
*
* toolHelp is the tool-specific help for the tool. It will be
* concatenated with the generic image tools help message and
* added to the toolCommand structure as the help string to be
* printed after the option listing.
*
* toolOptions is the tool-specific option list. It will be merged
* with the generic image tools options, and the list of image file
* format names supported by the library. This larger option list
* is then used as the list of options supported by the tool.
*
* toolEquivs is the tool-specific option equivalent keyword list.
* It will be merged with the generic image tools equivs. This large
* equivs list is then used as the list of equivs supported by the tool.
*/
private ArgCommand toolCommand =
{
/* command name */ "imgray",
/* major version # */ IMTOOLSMAJOR,
/* minor version # */ IMTOOLSMINOR,
/* subminor version # */ IMTOOLSSUBMINOR,
/* -help pre-option list information */
"%command converts each input image to grayscale and saves it to an output\n\
file. Input and output files may have different image file formats.\n\
",
/* -help post-option list information */
NULL, /* filled in later on */
/* -fullhelp pre-option list information */
NULL, /* Use same message as for -help*/
/* -fullhelp post-option list information */
NULL, /* filled in later on */
ARGFNONE, /* No special flags */
"[options...] infilename outfilename",
"[options...] infilename outfilename",
"SDSC Image Tools, October 1991.",
"Copyright (c) 1989-1991 San Diego Supercomputer Center (SDSC), CA, USA",
NULL, /* filled in later on */
NULL, /* filled in later on */
};
private char *toolHelp = "\n\
Typical Invocations:\n\
Convert an RGB Alias PIX image to a grayscale Sun rasterfile:\n\
%command fullcolor.pix gray.ras\n\
Convert a color Compuserve GIF image to a grayscale RGB Alias PIX image:\n\
%command color.gif gray.pix\n\
\n\
Additional Help:\n\
This is an abbreviated help listing. For a full listing of options,\n\
including a list of image file formats supported, type:\n\
%command -fullhelp\n\
";
private char *toolFullHelp = "\n\
Typical Invocations:\n\
Convert an RGB Alias PIX image to a grayscale Sun rasterfile:\n\
%command fullcolor.pix gray.ras\n\
Convert a color Compuserve GIF image to a grayscale RGB Alias PIX image:\n\
%command color.gif gray.pix\n\
\n\
Grayscale conversion:\n\
Conversion from color to grayscale computes the gray value for each\n\
pixel using the equation:\n\
\n\
gray = 0.30 * red + 0.59 * green + 0.11 * blue\n\
\n\
This is the same equation used by black-and-white televisions to display\n\
color signals in black-and-white.\n\
";
#define TOOLNOPTIONS 3
private ArgOption toolOptions[TOOLNOPTIONS] =
{
{ "infile", "image_filename", "Specify an input image file name",
ARGFREQUIRED | ARGFIMPKEYWORD, 1, 1, ARGTSTRING },
{ "outfile", "image_filename", "Specify an output image file name",
ARGFREQUIRED | ARGFIMPKEYWORD, 1, 1, ARGTSTRING },
{ "verbose", NULL, "Be verbose",
ARGFFULLHELP, 0, 0, ARGTNONE },
};
#define TOOLNEQUIVS 0
#if TOOLNEQUIVS == 0
private ArgEquiv *toolEquivs;
#else
private ArgEquiv toolEquivs[TOOLNEQUIVS] =
{
};
#endif
/*
* GLOBALS
* toolInFilename - the name of the input file (could be 'stdin')
* toolOutFilename - the name of the output file (could be 'stdout')
*
* toolInFormat - the name of the input file's format (could be NULL)
* toolOutFormat - the name of the output file's format (could be NULL)
*
* toolInTable - a table for the storage of data read in
* toolFlagsTable - a table for the storage of read/write flags
*
* DESCRIPTION
* Data held by these variables is used throughout the tool.
*/
private char toolInFilename[1024]; /* Input file name */
private char toolInFormat[1024]; /* Input file's format name */
private char toolOutFilename[1024];/* Output file name */
private char toolOutFormat[1024]; /* Output file's format name */
private TagTable *toolInTable; /* Data tag table */
private TagTable *toolFlagsTable; /* Flags tag table */
/*
* FUNCTION
* main - main program
*
* DESCRIPTION
* Control things:
* - Initialize things (parse arguments and set up tables).
* - Read in the input file (put data into data table).
* - Convert each image to grayscale.
* - Write out the output file (get data from data table).
* That's about it.
*
* NOTES
* This 'main' is pretty much the same for each of the image tools.
* Differences between tools include:
* - the number of input files read in
* - the number of output files written out
* - the actions taken on the data between read and write
*/
main( argc, argv )
int argc; /* Argument count */
char *argv[]; /* Argument vector */
{
int nInVfb; /* Number of images in file */
int i; /* Counter */
TagEntry *dataEntry; /* Entry from data table */
int w, h; /* Width and height of image */
int fields; /* Image fields */
ImVfb *sourceVfb; /* Source image */
ImVfb *grayVfb; /* New grayscale image */
/*
* Initialize things:
* - Prepare the arg parsing data, then parse the command-line.
* - Prepare the flags table based upon command-line args.
* - Determine the file formats for input and output files.
*/
toolInit( argc, argv );
/*
* Read in the input file.
* - Open the file (or stdin) and read data into the data table.
*/
ImToolsFileRead( toolInFilename, toolInFormat, toolFlagsTable,
toolInTable );
/*
* Check for errors
* - no input images
*/
nInVfb = TagTableQNEntry( toolInTable, "image vfb" );
if ( nInVfb == 0 )
{
fprintf( stderr, "%s: Input file contains no images!\n",
ImToolsProgram );
exit( 1 );
}
/*
* Convert to grayscale.
* - walk the input image list and convert each one to
* grayscale. Replace the input images with the new
* images.
*/
for ( i = 0; i < nInVfb; i++ )
{
/*
* Get the next image out of the data table.
*/
dataEntry = TagTableQDirect( toolInTable, "image vfb", i );
TagEntryQValue( dataEntry, &sourceVfb );
/*
* Make a new VFB with the same fields as the input VFB,
* but replace its image fields with a grayscale field.
*/
w = ImVfbQWidth( sourceVfb );
h = ImVfbQHeight( sourceVfb );
fields = ImVfbQFields( sourceVfb );
grayVfb = ImVfbAlloc( w, h,
(fields & ~IMVFBIMAGEMASK) | IMVFBGRAY );
if ( grayVfb == IMVFBNULL )
{
ImPError( ImToolsProgram );
fprintf( stderr, "%s: Couldn't create grayscale image for image %d of %d.\n",
ImToolsProgram, i + 1, nInVfb );
fprintf( stderr, "%s: Original image output.\n",
ImToolsProgram );
continue;
}
/*
* Copy all non-image fields from the original VFB to the
* new soon-to-be-grayscale VFB.
*/
if ( fields & ~IMVFBIMAGEMASK )
{
if ( ImVfbCopy( sourceVfb, /* Use this VFB */
0, 0, /* Start here */
w, h, /* This much */
(fields & ~IMVFBIMAGEMASK),/* This deep */
grayVfb, /* Put in VFB */
0, 0 ) == IMVFBNULL ) /* Put it here */
{
ImPError( ImToolsProgram );
fprintf( stderr, "%s: Couldn't create grayscale image for image %d of %d.\n",
ImToolsProgram, i + 1, nInVfb );
fprintf( stderr, "%s: Original image output.\n",
ImToolsProgram );
continue;
}
}
/*
* Convert the source image to grayscale and save the
* new pixels in the grayscale VFB.
*/
if ( ImToolsVerbose )
fprintf( stderr, "%s: Converting image %d of %d to grayscale\n",
ImToolsProgram,
i + 1, nInVfb );
ImVfbToGray( sourceVfb, grayVfb );
if ( grayVfb == IMVFBNULL )
{
ImPError( ImToolsProgram );
fprintf( stderr, "%s: Couldn't create grayscale image for image %d of %d.\n",
ImToolsProgram, i + 1, nInVfb );
fprintf( stderr, "%s: Original image output.\n",
ImToolsProgram );
continue;
}
/*
* Replace the source image with the grayscale image
* in the same data table.
*/
TagTableReplace( toolInTable,
TagEntryQNthEntry( dataEntry ),
TagEntryAlloc( "image vfb", POINTER, &grayVfb ) );
/*
* Destroy the source VFB.
*/
ImVfbFree( sourceVfb );
}
/*
* Write out the output file.
* - Open the file (or stdout) and write the data in the data
* table. Upon failure, remove the bad output file.
*/
ImToolsFileWrite( toolOutFilename, toolOutFormat, toolFlagsTable,
toolInTable );
exit( 0 );
}
/*
* FUNCTION
* toolInit - initialize things for the tool
*
* DESCRIPTION
* The tool's argument parsing data structures are set up to include:
* - the full help message (generic help + tool-specific help)
* - the full option list (generic options + tool-specific options)
* - the full equivs list (generic equivs + tool-specific equivs)
*
* Command-line arguments are then parsed. The results are used to
* set up the flags table (the generic -out* options).
*
* Input and output file's names and formats are determined from the
* command-line arguments.
*
* NOTES
* This function is included in most of the image tools and differs
* only in slight ways. Typical differences include:
* - the number of input and output file names found
* - the number of input and output file formats found
* - the number of command-line arg flags checked for
*/
private void /* Returns nothing */
toolInit( argc, argv )
int argc; /* Argument count */
char *argv[ ]; /* Argument vector */
{
int i; /* Counter */
int noccur; /* Number of option occurrences */
int nOpt; /* Number of options */
int nEquiv; /* Number of equivalences */
ArgOption *options1; /* Argument options */
ArgOption *options; /* Argument options */
ArgEquiv *equivs1; /* Argument equivalent keywords */
ArgEquiv *equivs; /* Argument equivalent keywords */
char *tmp; /* Temporary string holder */
char *tmpFormat; /* Tmp format name */
/*
* Save the name of the program, as invoked.
*/
ImToolsProgram = argv[0];
/*
* Make a data table to hold the incomming data.
*/
if ( (toolInTable = TagTableAlloc( )) == TAGTABLENULL )
{
TagPError( ImToolsProgram );
exit( 1 );
}
/*
* Use the standard Image Tools user registration and feedback forms.
*/
toolCommand.arg_register = ImToolsRegister;
toolCommand.arg_feedback = ImToolsFeedback;
/*
* Allocate space for the total help string for the tool. Copy the
* tool-specific help in, then concatenate on the generic help text
* used by most of the image tools.
*/
if ( (tmp = (char *)malloc( sizeof( char ) * (strlen( toolHelp ) + 1) )) == NULL )
{
perror( ImToolsProgram );
exit( 1 );
}
strcpy( tmp, toolHelp );
toolCommand.arg_help2 = tmp;
if ( (tmp = (char *)malloc( sizeof( char ) * (strlen( ImToolsBaseHelp) +
strlen( toolFullHelp ) + 1) )) == NULL )
{
perror( ImToolsProgram );
exit( 1 );
}
strcpy( tmp, toolFullHelp );
strcat( tmp, ImToolsBaseHelp );
toolCommand.arg_fullhelp2 = tmp;
/*
* Build up an option list by merging the tool-specific options,
* the standard (base) tool options, and those for the various
* image file formats.
*/
nOpt = ImToolsMergeOptions( TOOLNOPTIONS, toolOptions,
IMTOOLSNBASEOPTIONS, ImToolsBaseOptions, &options1 );
if ( (nOpt = ImFileFormatOptions( nOpt, options1, &options )) == -1)
{
ImPError( ImToolsProgram );
exit( 1 );
}
/*
* Build up an equivalent keyword list by merging the tool-specific
* equivalences, the standard (base) tool equivalences, and those
* for the various image file formats.
*/
nEquiv = ImToolsMergeEquivs( TOOLNEQUIVS, toolEquivs,
IMTOOLSNBASEEQUIVS, ImToolsBaseEquivs, &equivs1 );
if ( (nEquiv = ImFileFormatEquivs( nEquiv, equivs1, &equivs )) == -1)
{
ImPError( ImToolsProgram );
exit( 1 );
}
/*
* Parse the command line!
*/
nOpt = ArgParse( argc, argv, &toolCommand, nOpt, options,
nEquiv, equivs );
if ( ArgQNOccur( "verbose" ) != 0 )
ImToolsVerbose = TRUE;
/*
* Set up the flags table based upon command-line arguments.
* This is primarily derived from the -out* directives part of the
* standard image tool option set (see ImToolsBaseOptions above).
* Also included are flags to direct error messages to stderr and
* a flag giving the program's name for later use in error messages.
*/
toolFlagsTable = ImToolsBuildFlagsTable( );
/*
* Get the input file's name (-infile), and search backwards in the
* command-line option list to find the last format selection (if
* any). Stop the search on the beginning of the command-line, or
* on -outfile.
*/
strcpy( toolInFilename, ArgQValue( "infile", 0, 0 )->arg_s );
tmpFormat = NULL;
for ( i = ArgQOccurOpt( "infile", 0 ) - 1; i >= 0; i-- )
{
tmp = ArgQOpt( i, &noccur );
/*
* Stop looking backward when we reach any other file name
* argument.
*/
if ( strcmp( tmp, "outfile" ) == 0 )
break;
/*
* Skip it if it isn't the name of a file format.
*/
if ( !ImToolsIsFormat( tmp ) )
continue;
if ( tmpFormat != NULL )
{
fprintf( stderr, "%s: Only 1 file format selection may precede -infile.\n",
ImToolsProgram );
exit( 1 );
}
tmpFormat = tmp;
}
if ( tmpFormat == NULL )
*toolInFormat = '\0';
else
strcpy( toolInFormat, tmpFormat );
/*
* Get the output file's name (-outfile), and search backwards in the
* command-line option list to find the last format selection (if
* any). Stop the search on the beginning of the command-line, or
* on -infile.
*/
strcpy( toolOutFilename, ArgQValue( "outfile", 0, 0 )->arg_s );
tmpFormat = NULL;
for ( i = ArgQOccurOpt( "outfile", 0 ) - 1; i >= 0; i-- )
{
tmp = ArgQOpt( i, &noccur );
/*
* Stop looking backward when we reach any other file name
* argument.
*/
if ( strcmp( tmp, "infile" ) == 0 )
break;
/*
* Skip it if it isn't the name of a file format.
*/
if ( !ImToolsIsFormat( tmp ) )
continue;
if ( tmpFormat != NULL )
{
fprintf( stderr, "%s: Only 1 file format selection may precede -outfile.\n",
ImToolsProgram );
exit( 1 );
}
tmpFormat = tmp;
}
if ( tmpFormat == NULL )
*toolOutFormat = '\0';
else
strcpy( toolOutFormat, tmpFormat );
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.