int main( void )
{
led_init();
timer_init();
uart_init();
servo_init();
ppm_init();
adc_init();
input_init();
sei();
puts( "$Id: mainloop.c,v 2.14 2003/03/25 17:44:05 tramm Exp $\r\n" );
while( 1 )
{
input_task();
user_task();
if( ppm_valid )
{
ppm_output();
ppm_valid = 0;
}
/* Every 32768 microseconds */
if( timer_periodic() == 0 )
continue;
adc_output();
}
}
int
main(int argc, char *argv[]) {
int format;
int rows, cols;
pixval maxval;
int row;
pixel* pixelrow;
ppm_init(&argc, argv);
if (argc-1 != 0)
pm_error("Program takes no arguments. Input is from Standard Input");
ppm_readppminit(stdin, &cols, &rows, &maxval, &format);
ppm_writeppminit(stdout, cols, rows, maxval, 0);
pixelrow = ppm_allocrow(cols);
for (row = 0; row < rows; row++) {
ppm_readppmrow(stdin, pixelrow, cols, maxval, format);
ppm_writeppmrow(stdout, pixelrow, cols, maxval, 0);
}
ppm_freerow(pixelrow);
pm_close(stdin);
exit(0);
}
int
main(int argc, char ** argv)
{
struct ppm * picture;
color_t pixel;
int i, j;
picture = ppm_init(WIDTH, HEIGHT);
for(i = 0; i < WIDTH; i++)
{
for(j = 0; j < HEIGHT; j++)
{
pixel.red = (float)i * j / (WIDTH * HEIGHT) * 255;
//i == 2 && j == 2 ? 255 : 0;
pixel.green = 0;
pixel.blue = pixel.green;
ppm_write(picture, i, j, pixel);
}
}
ppm_save(picture, "picture.ppm");
return 0;
}
/********** INIT *************************************************************/
void init_rctx( void ) {
hw_init();
sys_time_init();
#ifdef LED
led_init();
#endif
#ifdef USE_UART1
Uart1Init();
#endif
#ifdef ADC
adc_init();
adc_buf_channel(ADC_CHANNEL_VSUPPLY, &vsupply_adc_buf, DEFAULT_AV_NB_SAMPLE);
#endif
#ifdef RADIO_CONTROL
ppm_init();
#endif
int_enable();
/** - wait 0.5s (for modem init ?) */
uint8_t init_cpt = 30;
while (init_cpt) {
if (sys_time_periodic())
init_cpt--;
}
#if defined DATALINK
#if DATALINK == XBEE
xbee_init();
#endif
#endif /* DATALINK */
}
int
main(int argc,
char * argv[]) {
struct cmdlineInfo cmdline;
FILE * ifP;
unsigned int cols, rows;
pixval maxval;
xvPalette xvPalette;
ppm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifP = pm_openr(cmdline.inputFileName);
makeXvPalette(&xvPalette);
readXvHeader(ifP, &cols, &rows, &maxval);
writePpm(ifP, &xvPalette, cols, rows, maxval, stdout);
pm_close(ifP);
return 0;
}
int
main(int argc, char *argv[]) {
struct cmdlineInfo cmdline;
pixel * pixrow;
unsigned int row;
ppm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ppm_writeppminit(stdout, cmdline.cols, cmdline.rows, cmdline.maxval, 0);
pixrow = ppm_allocrow(cmdline.cols);
for (row = 0; row < cmdline.rows; ++row) {
unsigned int col;
for (col = 0; col < cmdline.cols; ++col)
pixrow[col] = cmdline.color;
ppm_writeppmrow(stdout, pixrow, cmdline.cols, cmdline.maxval, 0);
}
ppm_freerow(pixrow);
pm_close(stdout);
return 0;
}
int main(int argc, char **argv) {
int i;
ppm_init(&argc, argv);
for (i = 1; i < argc; i++)
process_file(argv[i]);
return 0;
}
int main(int argc, char **argv)
{
FILE *ifp;
pixel **pixels;
int rows, row, cols, col,
pal_len, i;
pixval maxval;
struct cmdlineInfo
cmdline;
unsigned char rgb[NUM_COLORS][3];
char ansi_code[NUM_COLORS][MAX_ANSI_STR_LEN];
ppm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifp = pm_openr(cmdline.inputFilespec);
pixels = ppm_readppm(ifp, &cols, &rows, &maxval);
pm_close(ifp);
pal_len=generate_palette(rgb, ansi_code);
for (row = 0; row < rows; ++row) {
for (col = 0; col < cols; col++) {
pixval const r=(int)PPM_GETR(pixels[row][col])*255/maxval;
pixval const g=(int)PPM_GETG(pixels[row][col])*255/maxval;
pixval const b=(int)PPM_GETB(pixels[row][col])*255/maxval;
int val, dist;
/*
The following loop calculates the index that
corresponds to the minimum color distance
between the given RGB values and the values
available in the palette.
*/
for(i=0, dist=sqr(255)*3, val=0; i<pal_len; i++) {
pixval const pr=rgb[i][0];
pixval const pg=rgb[i][1];
pixval const pb=rgb[i][2];
unsigned int j;
if( (j=sqr(r-pr)+sqr(b-pb)+sqr(g-pg))<dist ) {
dist=j;
val=i;
}
}
printf("%s%c", ansi_code[val],0xB1);
}
printf(ESC"\x30m\n");
}
printf(ESC"\x30m");
ppm_freearray(pixels, rows);
exit(0);
}
int
main(int argc, char **argv) {
ppm_init(&argc, argv);
writeBuiltinFont(stdout);
return 0;
}
void main(void) {
//leds:
LED_INIT();
//init clock source XOSC:
clocksource_init();
//init uart
uart_init();
//init wdt timer
wdt_init();
apa102_init();
//init storage
storage_init();
//enable timeout routines
timeout_init();
//apa102_init();
//init frsky core
frsky_init();
//init adc
adc_init();
//init output
#if SBUS_ENABLED
sbus_init();
#else
ppm_init();
#endif
//init failsafe
failsafe_init();
debug("main: init done\n");
//run main
//frsky_frame_sniffer();
frsky_main();
LED_RED_ON();
while (1) {
LED_RED_ON();
delay_ms(200);
LED_RED_OFF();
delay_ms(200);
}
}
int
main(int argc, char *argv[]) {
struct cmdlineInfo cmdline;
FILE * ifP;
/* Parameters of input image: */
int rows, cols;
pixval maxval;
int format;
ppm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifP = pm_openr(cmdline.inputFilename);
ppm_readppminit(ifP, &cols, &rows, &maxval, &format);
pbm_writepbminit(stdout, cols, rows, 0);
{
pixel * const inputRow = ppm_allocrow(cols);
bit * const maskRow = pbm_allocrow(cols);
unsigned int numPixelsMasked;
unsigned int row;
for (row = 0, numPixelsMasked = 0; row < rows; ++row) {
int col;
ppm_readppmrow(ifP, inputRow, cols, maxval, format);
for (col = 0; col < cols; ++col) {
if (colorIsInSet(inputRow[col], maxval, cmdline)) {
maskRow[col] = PBM_BLACK;
++numPixelsMasked;
} else
maskRow[col] = PBM_WHITE;
}
pbm_writepbmrow(stdout, maskRow, cols, 0);
}
if (cmdline.verbose)
pm_message("%u pixels found matching %u requested colors",
numPixelsMasked, cmdline.colorCount);
pbm_freerow(maskRow);
ppm_freerow(inputRow);
}
pm_close(ifP);
return 0;
}
int main(void) {
// leds:
led_init();
// init clock sources:
clocksource_init();
// init ios
io_init();
// init debug
debug_init();
// init wdt timer
wdt_init();
// enable timeout routines
timeout_init();
// init storage
storage_init();
// init frsky core
frsky_init();
// init adc
adc_init();
// init output
#ifdef SBUS_ENABLED
sbus_init();
#else // SBUS_ENABLED
ppm_init();
#endif // SBUS_ENABLED
// init failsafe
failsafe_init();
// init telemetry
telemetry_init();
// run main
debug("main: init done\n");
// frsky_frame_sniffer();
frsky_main();
debug("main: frsky main ended?! THIS SHOULD NOT HAPPEN!");
while (1) {}
}
int
main(int argc, char *argv[]) {
FILE *ifp;
FILE *alpha_file, *imageout_file;
pixel *colormap;
int cols, rows;
int transparent; /* value of 'data' that means transparent */
int *data;
/* The image as an array of width * height integers, each one
being an index int colormap[].
*/
struct cmdline_info cmdline;
ppm_init(&argc, argv);
parse_command_line(argc, argv, &cmdline);
verbose = cmdline.verbose;
if ( cmdline.input_filespec != NULL )
ifp = pm_openr( cmdline.input_filespec);
else
ifp = stdin;
if (cmdline.alpha_stdout)
alpha_file = stdout;
else if (cmdline.alpha_filename == NULL)
alpha_file = NULL;
else {
alpha_file = pm_openw(cmdline.alpha_filename);
}
if (cmdline.alpha_stdout)
imageout_file = NULL;
else
imageout_file = stdout;
ReadXPMFile(ifp, &cols, &rows, &colormap, &data, &transparent);
pm_close(ifp);
writeOutput(imageout_file, alpha_file, cols, rows, colormap, data,
transparent);
free(colormap);
return 0;
}
void fbw_init(void) {
uart_init_tx();
uart_print_string("FBW Booting $Id: main.c,v 1.3 2008/10/22 19:41:19 casse Exp $\n");
#ifndef CTL_BRD_V1_1
fbw_adc_init();
fbw_adc_buf_channel(3, &vsupply_adc_buf);
fbw_adc_buf_channel(6, &vservos_adc_buf);
#endif
timer_init();
servo_init();
ppm_init();
fbw_spi_init();
//sei(); //FN
}
void fbw_init(void) {
uart_init_tx();
uart_print_string("FBW Booting $Id: main.c,v 1.4 2011-01-25 10:42:14 plazar Exp $\n");
#ifndef CTL_BRD_V1_1
fbw_adc_init();
fbw_adc_buf_channel(3, &vsupply_adc_buf);
fbw_adc_buf_channel(6, &vservos_adc_buf);
#endif
timer_init();
servo_init();
ppm_init();
fbw_spi_init();
//sei(); //FN
}
int
main(int argc, char *argv[]) {
FILE* ifP;
const char * inputFilespec;
int eof;
ppm_init( &argc, argv );
if (argc-1 > 1)
pm_error("The only argument is the (optional) input filename");
if (argc == 2)
inputFilespec = argv[1];
else
inputFilespec = "-";
ifP = pm_openr(inputFilespec);
eof = FALSE; /* initial assumption */
while (!eof) {
ppm_nextimage(ifP, &eof);
if (!eof) {
int rows, cols, format;
pixval maxval;
pixel* inputRow;
gray* outputRow;
ppm_readppminit(ifP, &cols, &rows, &maxval, &format);
pgm_writepgminit(stdout, cols, rows, maxval, 0);
inputRow = ppm_allocrow(cols);
outputRow = pgm_allocrow(cols);
convertRaster(ifP, cols, rows, maxval, format,
inputRow, outputRow, stdout);
ppm_freerow(inputRow);
pgm_freerow(outputRow);
}
}
pm_close(ifP);
pm_close(stdout);
return 0;
}
int main(int argc, char **argv) {
int i;
ppm_init(&argc, argv);
for (i = 0; i < 256; i++)
PPM_ASSIGN(cmap[i], i, i, i);
i = 1;
if (argc >= 3 && strncmp(argv[1], "-c", 2) == 0) {
read_cmp(argv[2]);
i = 3;
}
for (; i < argc; i++)
process_file(argv[i]);
return 0;
}
int
main(int argc, char ** argv) {
struct cmdlineInfo cmdline;
MS_Ico const MSIconDataP = createIconFile();
unsigned int iconIndex;
unsigned int offset;
ppm_init (&argc, argv);
parseCommandLine(argc, argv, &cmdline);
verbose = cmdline.verbose;
for (iconIndex = 0; iconIndex < cmdline.iconCount; ++iconIndex) {
addEntryToIcon(MSIconDataP, cmdline.inputFilespec[iconIndex],
cmdline.andpgmFilespec[iconIndex],
cmdline.truetransparent);
}
/*
* Now we have to go through and calculate the offsets.
* The first infoheader starts at 6 + count*16 bytes.
*/
offset = (MSIconDataP->count * 16) + 6;
for (iconIndex = 0; iconIndex < MSIconDataP->count; ++iconIndex) {
IC_Entry entry = MSIconDataP->entries[iconIndex];
entry->file_offset = offset;
/*
* Increase the offset by the size of this offset & data.
* this includes the size of the color data.
*/
offset += entry->size_in_bytes;
}
/*
* And now, we have to actually SAVE the .ico!
*/
writeMS_Ico(MSIconDataP, cmdline.output);
free(cmdline.inputFilespec);
free(cmdline.andpgmFilespec);
return 0;
}
static void csc_main_init( void ) {
mcu_init();
sys_time_init();
led_init();
Uart0Init();
Uart1Init();
ppm_init();
// Configure P0.21 as GPIO, output and then pull high as we use it to drive ppm input transistor
PINSEL1 = PINSEL1 & ~(0x3 << 10);
IO0DIR = IO0DIR | (0x1 << 21);
IO0PIN = IO0DIR | (0x1 << 21);
mcu_int_enable();
}
/********** INIT *************************************************************/
void init_fbw( void ) {
hw_init();
sys_time_init();
#ifdef LED
led_init();
#endif
#ifdef USE_UART0
uart0_init_tx();
#endif
#ifdef USE_UART1
uart1_init_tx();
#endif
#ifdef ADC
adc_init();
adc_buf_channel(ADC_CHANNEL_VSUPPLY, &vsupply_adc_buf, DEFAULT_AV_NB_SAMPLE);
#endif
#ifdef ACTUATORS
actuators_init();
/* Load the failsafe defaults */
SetCommands(commands_failsafe);
#endif
#ifdef RADIO_CONTROL
ppm_init();
#endif
#ifdef INTER_MCU
inter_mcu_init();
#endif
#ifdef MCU_SPI_LINK
spi_init();
link_mcu_restart();
#endif
#ifdef LINK_IMU
spi_init();
link_imu_init();
#endif
#ifdef CTL_GRZ
ctl_grz_init();
#endif
#ifndef SINGLE_MCU
int_enable();
#endif
}
int
main(int argc,
char * argv[]) {
FILE * ifP;
struct cmdlineInfo cmdline;
gray * grayrow;
pixel * pixelrow;
int rows, cols, format;
gray maxval;
ppm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifP = pm_openr(cmdline.inputFilename);
pgm_readpgminit(ifP, &cols, &rows, &maxval, &format);
grayrow = pgm_allocrow(cols);
pixelrow = ppm_allocrow(cols);
if (cmdline.map)
convertWithMap(ifP, cols, rows, maxval, format, cmdline.map,
stdout, grayrow, pixelrow);
else
convertLinear(ifP, cols, rows, maxval, format,
cmdline.colorBlack, cmdline.colorWhite, stdout,
grayrow, pixelrow);
ppm_freerow(pixelrow);
pgm_freerow(grayrow);
pm_close(ifP);
/* If the program failed, it previously aborted with nonzero completion
code, via various function calls.
*/
return 0;
}
/**
* @brief Initialize the whole system
*
* All functions that need to be called before the first mainloop iteration
* should be placed here.
*/
void main_init_generic(void)
{
// Reset to safe values
global_data_reset();
// Load default eeprom parameters as fallback
global_data_reset_param_defaults();
// LOWLEVEL INIT, ONLY VERY BASIC SYSTEM FUNCTIONS
hw_init();
enableIRQ();
led_init();
led_on(LED_GREEN);
buzzer_init();
sys_time_init();
sys_time_periodic_init();
sys_time_clock_init();
ppm_init();
pwm_init();
// Lowlevel periphel support init
adc_init();
// FIXME SDCARD
// MMC_IO_Init();
spi_init();
i2c_init();
// Sensor init
sensors_init();
debug_message_buffer("Sensor initialized");
// Shutter init
shutter_init();
shutter_control(0);
// Debug output init
debug_message_init();
debug_message_buffer("Text message buffer initialized");
// MEDIUM LEVEL INIT, INITIALIZE I2C, EEPROM, WAIT FOR MOTOR CONTROLLERS
// Try to reach the EEPROM
eeprom_check_start();
// WAIT FOR 2 SECONDS FOR THE USER TO NOT TOUCH THE UNIT
while (sys_time_clock_get_time_usec() < 2000000)
{
}
// Do the auto-gyro calibration for 1 second
// Get current temperature
led_on(LED_RED);
gyro_init();
// uint8_t timeout = 3;
// // Check for SD card
// while (sys_time_clock_get_time_usec() < 2000000)
// {
// while (GetDriveInformation() != F_OK && timeout--)
// {
// debug_message_buffer("MMC/SD-Card not found ! retrying..");
// }
// }
//
// if (GetDriveInformation() == F_OK)
// {
// debug_message_buffer("MMC/SD-Card SUCCESS: FOUND");
// }
// else
// {
// debug_message_buffer("MMC/SD-Card FAILURE: NOT FOUND");
// }
//FIXME redo init because of SD driver decreasing speed
//spi_init();
led_off(LED_RED);
// Stop trying to reach the EEPROM - if it has not been found by now, assume
// there is no EEPROM mounted
if (eeprom_check_ok())
{
param_read_all();
debug_message_buffer("EEPROM detected - reading parameters from EEPROM");
for (int i = 0; i < ONBOARD_PARAM_COUNT * 2 + 20; i++)
{
param_handler();
//sleep 1 ms
sys_time_wait(1000);
}
}
else
{
debug_message_buffer("NO EEPROM - reading onboard parameters from FLASH");
}
// Set mavlink system
mavlink_system.compid = MAV_COMP_ID_IMU;
mavlink_system.sysid = global_data.param[PARAM_SYSTEM_ID];
//Magnet sensor
hmc5843_init();
acc_init();
// Comm parameter init
mavlink_system.sysid = global_data.param[PARAM_SYSTEM_ID]; // System ID, 1-255
mavlink_system.compid = global_data.param[PARAM_COMPONENT_ID]; // Component/Subsystem ID, 1-255
// Comm init has to be
// AFTER PARAM INIT
comm_init(MAVLINK_COMM_0);
comm_init(MAVLINK_COMM_1);
// UART initialized, now initialize COMM peripherals
communication_init();
gps_init();
us_run_init();
servos_init();
//position_kalman3_init();
// Calibration starts (this can take a few seconds)
// led_on(LED_GREEN);
// led_on(LED_RED);
// Read out first time battery
global_data.battery_voltage = battery_get_value();
global_data.state.mav_mode = MAV_MODE_PREFLIGHT;
global_data.state.status = MAV_STATE_CALIBRATING;
send_system_state();
float_vect3 init_state_accel;
init_state_accel.x = 0.0f;
init_state_accel.y = 0.0f;
init_state_accel.z = -1000.0f;
float_vect3 init_state_magnet;
init_state_magnet.x = 1.0f;
init_state_magnet.y = 0.0f;
init_state_magnet.z = 0.0f;
//auto_calibration();
attitude_observer_init(init_state_accel, init_state_magnet);
debug_message_buffer("Attitude Filter initialized");
led_on(LED_RED);
send_system_state();
debug_message_buffer("System is initialized");
// Calibration stopped
led_off(LED_RED);
global_data.state.mav_mode = MAV_MODE_FLAG_MANUAL_INPUT_ENABLED;
global_data.state.status = MAV_STATE_STANDBY;
send_system_state();
debug_message_buffer("Checking if remote control is switched on:");
// Initialize remote control status
remote_control();
remote_control();
if (radio_control_status() == RADIO_CONTROL_ON && global_data.state.remote_ok)
{
global_data.state.mav_mode = MAV_MODE_FLAG_MANUAL_INPUT_ENABLED | MAV_MODE_FLAG_TEST_ENABLED;
debug_message_buffer("RESULT: remote control switched ON");
debug_message_buffer("Now in MAV_MODE_TEST2 position hold tobi_laurens");
led_on(LED_GREEN);
}
else
{
global_data.state.mav_mode = MAV_MODE_FLAG_MANUAL_INPUT_ENABLED;
debug_message_buffer("RESULT: remote control switched OFF");
led_off(LED_GREEN);
}
}
int
main(int argc, char **argv) {
struct cmdlineInfo cmdline;
FILE *vf,*uf,*yf;
int cols, rows;
pixel *pixelrow1,*pixelrow2;
int row;
unsigned char *y1buf,*y2buf,*ubuf,*vbuf;
const char * ufname;
const char * vfname;
const char * yfname;
ppm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
asprintfN(&ufname, "%s.U", cmdline.filenameBase);
asprintfN(&vfname, "%s.V", cmdline.filenameBase);
asprintfN(&yfname, "%s.Y", cmdline.filenameBase);
uf = pm_openr(ufname);
vf = pm_openr(vfname);
yf = pm_openr(yfname);
ppm_writeppminit(stdout, cmdline.width, cmdline.height, 255, 0);
if (cmdline.width % 2 != 0) {
pm_message("Warning: odd width; last column ignored");
cols = cmdline.width - 1;
} else
cols = cmdline.width;
if (cmdline.height % 2 != 0) {
pm_message("Warning: odd height; last row ignored");
rows = cmdline.height - 1;
} else
rows = cmdline.height;
pixelrow1 = ppm_allocrow(cols);
pixelrow2 = ppm_allocrow(cols);
MALLOCARRAY_NOFAIL(y1buf, cmdline.width);
MALLOCARRAY_NOFAIL(y2buf, cmdline.width);
MALLOCARRAY_NOFAIL(ubuf, cmdline.width/2);
MALLOCARRAY_NOFAIL(vbuf, cmdline.width/2);
for (row = 0; row < rows; row += 2) {
fread(y1buf, cmdline.width, 1, yf);
fread(y2buf, cmdline.width, 1, yf);
fread(ubuf, cmdline.width/2, 1, uf);
fread(vbuf, cmdline.width/2, 1, vf);
computeTwoOutputRows(cols, cmdline.ccir601,
y1buf, y2buf, ubuf, vbuf,
pixelrow1, pixelrow2);
ppm_writeppmrow(stdout, pixelrow1, cols, (pixval) 255, 0);
ppm_writeppmrow(stdout, pixelrow2, cols, (pixval) 255, 0);
}
pm_close(stdout);
strfree(yfname);
strfree(vfname);
strfree(ufname);
pm_close(yf);
pm_close(uf);
pm_close(vf);
exit(0);
}
int
main(int argc,
char * argv[]) {
int argn;
const char * const usage = "[-[no]black] [-[no]wpoint] [-[no]label] [-no[axes]] [-full]\n\
[-xy|-upvp] [-rec709|-ntsc|-ebu|-smpte|-hdtv|-cie]\n\
[-red <x> <y>] [-green <x> <y>] [-blue <x> <y>]\n\
[-white <x> <y>] [-gamma <g>]\n\
[-size <s>] [-xsize|-width <x>] [-ysize|-height <y>]";
const struct colorSystem *cs;
int widspec = FALSE, hgtspec = FALSE;
int xBias, yBias;
int upvp = FALSE; /* xy or u'v' color coordinates? */
int showWhite = TRUE; /* Show white point ? */
int showBlack = TRUE; /* Show black body curve ? */
int fullChart = FALSE; /* Fill entire tongue ? */
int showLabel = TRUE; /* Show labels ? */
int showAxes = TRUE; /* Plot axes ? */
ppm_init(&argc, argv);
argn = 1;
cs = &Rec709system; /* default */
while (argn < argc && argv[argn][0] == '-' && argv[argn][1] != '\0') {
if (pm_keymatch(argv[argn], "-xy", 2)) {
upvp = FALSE;
} else if (pm_keymatch(argv[argn], "-upvp", 1)) {
upvp = TRUE;
} else if (pm_keymatch(argv[argn], "-xsize", 1) ||
pm_keymatch(argv[argn], "-width", 2)) {
if (widspec) {
pm_error("already specified a size/width/xsize");
}
argn++;
if ((argn == argc) || (sscanf(argv[argn], "%d", &sxsize) != 1))
pm_usage(usage);
widspec = TRUE;
} else if (pm_keymatch(argv[argn], "-ysize", 1) ||
pm_keymatch(argv[argn], "-height", 2)) {
if (hgtspec) {
pm_error("already specified a size/height/ysize");
}
argn++;
if ((argn == argc) || (sscanf(argv[argn], "%d", &sysize) != 1))
pm_usage(usage);
hgtspec = TRUE;
} else if (pm_keymatch(argv[argn], "-size", 2)) {
if (hgtspec || widspec) {
pm_error("already specified a size/height/ysize");
}
argn++;
if ((argn == argc) || (sscanf(argv[argn], "%d", &sysize) != 1))
pm_usage(usage);
sxsize = sysize;
hgtspec = widspec = TRUE;
} else if (pm_keymatch(argv[argn], "-rec709", 1)) {
cs = &Rec709system;
} else if (pm_keymatch(argv[argn], "-ntsc", 1)) {
cs = &NTSCsystem;
} else if (pm_keymatch(argv[argn], "-ebu", 1)) {
cs = &EBUsystem;
} else if (pm_keymatch(argv[argn], "-smpte", 2)) {
cs = &SMPTEsystem;
} else if (pm_keymatch(argv[argn], "-hdtv", 2)) {
cs = &HDTVsystem;
} else if (pm_keymatch(argv[argn], "-cie", 1)) {
cs = &CIEsystem;
} else if (pm_keymatch(argv[argn], "-black", 3)) {
showBlack = TRUE; /* Show black body curve */
} else if (pm_keymatch(argv[argn], "-wpoint", 2)) {
showWhite = TRUE; /* Show white point of color system */
} else if (pm_keymatch(argv[argn], "-noblack", 3)) {
showBlack = FALSE; /* Don't show black body curve */
} else if (pm_keymatch(argv[argn], "-nowpoint", 3)) {
showWhite = FALSE; /* Don't show white point of system */
} else if (pm_keymatch(argv[argn], "-label", 1)) {
showLabel = TRUE; /* Show labels. */
} else if (pm_keymatch(argv[argn], "-nolabel", 3)) {
showLabel = FALSE; /* Don't show labels */
} else if (pm_keymatch(argv[argn], "-axes", 1)) {
showAxes = TRUE; /* Show axes. */
} else if (pm_keymatch(argv[argn], "-noaxes", 3)) {
showAxes = FALSE; /* Don't show axes */
} else if (pm_keymatch(argv[argn], "-full", 1)) {
fullChart = TRUE; /* Fill whole tongue full-intensity */
} else if (pm_keymatch(argv[argn], "-gamma", 2)) {
cs = &Customsystem;
argn++;
if ((argn == argc) ||
(sscanf(argv[argn], "%lf", &Customsystem.gamma) != 1))
pm_usage(usage);
} else if (pm_keymatch(argv[argn], "-red", 1)) {
cs = &Customsystem;
argn++;
if ((argn == argc) ||
(sscanf(argv[argn], "%lf", &Customsystem.xRed) != 1))
pm_usage(usage);
argn++;
if ((argn == argc) ||
(sscanf(argv[argn], "%lf", &Customsystem.yRed) != 1))
pm_usage(usage);
} else if (pm_keymatch(argv[argn], "-green", 1)) {
cs = &Customsystem;
argn++;
if ((argn == argc) ||
(sscanf(argv[argn], "%lf", &Customsystem.xGreen) != 1))
pm_usage(usage);
argn++;
if ((argn == argc) ||
(sscanf(argv[argn], "%lf", &Customsystem.yGreen) != 1))
pm_usage(usage);
} else if (pm_keymatch(argv[argn], "-blue", 1)) {
cs = &Customsystem;
argn++;
if ((argn == argc) ||
(sscanf(argv[argn], "%lf", &Customsystem.xBlue) != 1))
pm_usage(usage);
argn++;
if ((argn == argc) ||
(sscanf(argv[argn], "%lf", &Customsystem.yBlue) != 1))
pm_usage(usage);
} else if (pm_keymatch(argv[argn], "-white", 1)) {
cs = &Customsystem;
argn++;
if ((argn == argc) ||
(sscanf(argv[argn], "%lf", &Customsystem.xWhite) != 1))
pm_usage(usage);
argn++;
if ((argn == argc) ||
(sscanf(argv[argn], "%lf", &Customsystem.yWhite) != 1))
pm_usage(usage);
} else {
pm_usage(usage);
}
argn++;
}
if (argn != argc) { /* Extra bogus arguments ? */
pm_usage(usage);
}
pixcols = sxsize;
pixrows = sysize;
pixels = ppm_allocarray(pixcols, pixrows);
/* Partition into plot area and axes and establish subwindow. */
xBias = Sz(32);
yBias = Sz(20);
makeAllBlack(pixels, pixcols, pixrows);
drawTongueOutline(pixels, pixcols, pixrows, Maxval, upvp, xBias, yBias);
fillInTongue(pixels, pixcols, pixrows, Maxval, cs, upvp, xBias, yBias,
fullChart);
if (showAxes)
drawAxes(pixels, pixcols, pixrows, Maxval, upvp, xBias, yBias);
if (showWhite)
plotWhitePoint(pixels, pixcols, pixrows, Maxval,
cs, upvp, xBias, yBias);
if (showBlack)
plotBlackBodyCurve(pixels, pixcols, pixrows, Maxval,
upvp, xBias, yBias);
/* Plot wavelengths around periphery of the tongue. */
if (showAxes)
plotMonochromeWavelengths(pixels, pixcols, pixrows, Maxval,
cs, upvp, xBias, yBias);
if (showLabel)
writeLabel(pixels, pixcols, pixrows, Maxval, cs);
ppm_writeppm(stdout, pixels, pixcols, pixrows, Maxval, FALSE);
return 0;
}
int
main (int argc, char *argv[]) {
int offset;
int cols, rows, row;
pixel* pixelrow;
pixval maxval;
FILE* Lifp;
pixel* Lpixelrow;
gray* Lgrayrow;
int Lrows, Lcols, Lformat;
pixval Lmaxval;
FILE* Rifp;
pixel* Rpixelrow;
gray* Rgrayrow;
int Rrows, Rcols, Rformat;
pixval Rmaxval;
ppm_init (&argc, argv);
if (argc-1 > 3 || argc-1 < 2)
pm_error("Wrong number of arguments (%d). Arguments are "
"leftppmfile rightppmfile [horizontal_offset]", argc-1);
Lifp = pm_openr (argv[1]);
Rifp = pm_openr (argv[2]);
if (argc-1 >= 3)
offset = atoi (argv[3]);
else
offset = 30;
ppm_readppminit (Lifp, &Lcols, &Lrows, &Lmaxval, &Lformat);
ppm_readppminit (Rifp, &Rcols, &Rrows, &Rmaxval, &Rformat);
if ((Lcols != Rcols) || (Lrows != Rrows) ||
(Lmaxval != Rmaxval) ||
(PPM_FORMAT_TYPE(Lformat) != PPM_FORMAT_TYPE(Rformat)))
pm_error ("Pictures are not of same size and format");
cols = Lcols;
rows = Lrows;
maxval = Lmaxval;
ppm_writeppminit (stdout, cols, rows, maxval, 0);
Lpixelrow = ppm_allocrow (cols);
Lgrayrow = pgm_allocrow (cols);
Rpixelrow = ppm_allocrow (cols);
Rgrayrow = pgm_allocrow (cols);
pixelrow = ppm_allocrow (cols);
for (row = 0; row < rows; ++row) {
ppm_readppmrow(Lifp, Lpixelrow, cols, maxval, Lformat);
ppm_readppmrow(Rifp, Rpixelrow, cols, maxval, Rformat);
computeGrayscaleRow(Lpixelrow, Lgrayrow, maxval, cols);
computeGrayscaleRow(Rpixelrow, Rgrayrow, maxval, cols);
{
int col;
gray* LgP;
gray* RgP;
pixel* pP;
for (col = 0, pP = pixelrow, LgP = Lgrayrow, RgP = Rgrayrow;
col < cols + offset;
++col) {
if (col < offset/2)
++LgP;
else if (col >= offset/2 && col < offset) {
const pixval Blue = (pixval) (float) *LgP;
const pixval Red = (pixval) 0;
PPM_ASSIGN (*pP, Red, Blue, Blue);
++LgP;
++pP;
} else if (col >= offset && col < cols) {
const pixval Red = (pixval) (float) *RgP;
const pixval Blue = (pixval) (float) *LgP;
PPM_ASSIGN (*pP, Red, Blue, Blue);
++LgP;
++RgP;
++pP;
} else if (col >= cols && col < cols + offset/2) {
const pixval Blue = (pixval) 0;
const pixval Red = (pixval) (float) *RgP;
PPM_ASSIGN (*pP, Red, Blue, Blue);
++RgP;
++pP;
} else
++RgP;
}
}
ppm_writeppmrow(stdout, pixelrow, cols, maxval, 0);
}
pm_close(Lifp);
pm_close(Rifp);
pm_close(stdout);
return 0;
}
int main(int argc, char *argv[])
{
bool gui = false;
QApplication app(argc, argv, gui);
QProxyStyle * style = new QProxyStyle();
app.setStyle(style);
struct statsd_info
{
statsd_info() : host("127.0.0.1"), port(8125), ns(std::string(ICHABOD_NAME)+"."), enabled(false) {}
std::string host;
int port;
std::string ns;
bool enabled;
};
statsd_info statsd;
int port = 9090;
QStringList args = app.arguments();
QRegExp rxPort("--port=([0-9]{1,})");
QRegExp rxVerbose("--verbosity=([0-9]{1,})");
QRegExp rxEngineVerbose("--engine-verbosity=([0-9]{1,})");
QRegExp rxConvertVerbose("--convert-verbosity=([0-9]{1,})");
QRegExp rxSlowResponseMs("--slow-response-ms=([0-9]{1,})");
QRegExp rxQuantize("--quantize=([a-zA-Z]{1,})");
QRegExp rxVersion("--version");
QRegExp rxShortVersion("-v$");
QRegExp rxStatsdHost("--statsd-host=([^ ]+)");
QRegExp rxStatsdPort("--statsd-port=([0-9]{1,})");
QRegExp rxStatsdNs("--statsd-ns=([^ ]+)");
for (int i = 1; i < args.size(); ++i) {
if (rxPort.indexIn(args.at(i)) != -1 )
{
port = rxPort.cap(1).toInt();
}
else if (rxVerbose.indexIn(args.at(i)) != -1 )
{
g_verbosity = rxVerbose.cap(1).toInt();
}
else if (rxEngineVerbose.indexIn(args.at(i)) != -1 )
{
g_engine_verbosity = rxEngineVerbose.cap(1).toInt();
}
else if (rxConvertVerbose.indexIn(args.at(i)) != -1 )
{
g_convert_verbosity = rxConvertVerbose.cap(1).toInt();
}
else if (rxSlowResponseMs.indexIn(args.at(i)) != -1 )
{
g_slow_response_ms = rxSlowResponseMs.cap(1).toInt();
}
else if (rxQuantize.indexIn(args.at(i)) != -1 )
{
g_quantize = rxQuantize.cap(1);
}
else if (rxVersion.indexIn(args.at(i)) != -1 )
{
std::cout << ICHABOD_NAME << " version " << ICHABOD_VERSION << std::endl;
std::cout << "** The GIFLIB distribution is Copyright (c) 1997 Eric S. Raymond" << std::endl;
std::cout << "** ppmquant is Copyright (C) 1989, 1991 by Jef Poskanzer." << std::endl;
std::cout << "** statsd-client-cpp is Copyright (c) 2014, Rex" << std::endl;
std::cout << "**" << std::endl;
std::cout << "** Permission to use, copy, modify, and distribute this software and its" << std::endl;
std::cout << "** documentation for any purpose and without fee is hereby granted, provided" << std::endl;
std::cout << "** that the above copyright notice appear in all copies and that both that" << std::endl;
std::cout << "** copyright notice and this permission notice appear in supporting" << std::endl;
std::cout << "** documentation. This software is provided \"as is\" without express or" << std::endl;
std::cout << "** implied warranty." << std::endl;
std::cout << "**" << std::endl;
ppm_init( &argc, argv );
return 0;
}
else if (rxShortVersion.indexIn(args.at(i)) != -1)
{
std::cout << ICHABOD_VERSION << std::endl;
return 0;
}
else if (rxStatsdHost.indexIn(args.at(i)) != -1)
{
statsd.host = rxStatsdHost.cap(1).toLocal8Bit().constData();
statsd.enabled = true;
}
else if (rxStatsdPort.indexIn(args.at(i)) != -1)
{
statsd.port = rxStatsdPort.cap(1).toInt();
statsd.enabled = true;
}
else if (rxStatsdNs.indexIn(args.at(i)) != -1)
{
statsd.ns = rxStatsdNs.cap(1).toLocal8Bit().constData();
if ( statsd.ns.length() && *statsd.ns.rbegin() != '.' )
{
statsd.ns += ".";
}
statsd.enabled = true;
}
else
{
std::cerr << "Unknown arg:" << args.at(i).toLocal8Bit().constData() << std::endl;
return -1;
}
}
ppm_init( &argc, argv );
struct mg_server *server = mg_create_server(NULL, ev_handler);
const char * err = mg_set_option(server, "listening_port", QString::number(port).toLocal8Bit().constData());
if ( err )
{
std::cerr << "Cannot bind to port:" << port << " [" << err << "], exiting." << std::endl;
return -1;
}
std::cout << ICHABOD_NAME << " " << ICHABOD_VERSION
<< " (port:" << mg_get_option(server, "listening_port")
<< " verbosity:" << g_verbosity
<< " engine verbosity:" << g_engine_verbosity
<< " convert verbosity:" << g_convert_verbosity
<< " slow-response:" << g_slow_response_ms << "ms";
if ( statsd.enabled )
{
std::cout << " statsd:" << statsd.host << ":" << statsd.port << "[" << statsd.ns << "]";
g_statsd.config(statsd.host, statsd.port, statsd.ns);
}
std::cout << ")" << std::endl;
for (;;)
{
mg_poll_server(server, 1000);
}
mg_destroy_server(&server);
return 0;
}
int
main(int argc, char *argv[]) {
FILE *ifp;
int rows, cols;
unsigned int ncolors;
bool transparentSomewhere;
pixval maxval, alphaMaxval;
colorhash_table cht;
colorhist_vector chv;
colorhash_table colornameHash;
/* Hash table to map colors to their names */
const char ** colornames;
/* Table of color names; 'colornameHash' yields an index into this
array.
*/
pixel **pixels;
gray **alpha;
/* Used for rgb value -> character-pixel string mapping */
cixel_map *cmap; /* malloc'ed */
/* The XPM colormap */
unsigned int cmapSize;
/* Number of entries in 'cmap' */
unsigned int transIndex;
/* Index into 'cmap' of the transparent color, if there is one */
unsigned int charsPerPixel;
struct cmdlineInfo cmdline;
ppm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifp = pm_openr(cmdline.inputFilename);
pixels = ppm_readppm(ifp, &cols, &rows, &maxval);
pm_close(ifp);
if (cmdline.alpha_filename)
readAlpha(cmdline.alpha_filename, &alpha, cols, rows, &alphaMaxval);
else
alpha = NULL;
computeColormap(pixels, alpha, cols, rows, alphaMaxval,
&chv, &cht, &ncolors, &transparentSomewhere);
if (cmdline.hexonly)
colornameHash = NULL;
else if (cmdline.rgb)
ppm_readcolornamefile(cmdline.rgb, TRUE, &colornameHash, &colornames);
else
ppm_readcolornamefile(NULL, FALSE, &colornameHash, &colornames);
/* Now generate the character-pixel colormap table. */
genCmap(chv, ncolors, maxval,
colornameHash, colornames, transparentSomewhere,
&cmap, &transIndex, &cmapSize, &charsPerPixel);
writeXpmFile(stdout, pixels, alpha, alphaMaxval,
cmdline.name, cols, rows, cmapSize,
charsPerPixel, cmap, cht, transIndex);
if (colornameHash) {
ppm_freecolorhash(colornameHash);
ppm_freecolornames(colornames);
}
destroyCmap(cmap, cmapSize);
ppm_freearray(pixels, rows);
if (alpha) pgm_freearray(alpha, rows);
return 0;
}
int
main(int argc, char *argv[]) {
struct cmdlineInfo cmdline;
FILE* ifP;
int rows, cols;
pixval maxval;
pixel **pixels;
struct pcxCmapEntry * pcxcmap;
colorhash_table cht;
bool truecolor;
int colors;
ppm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifP = pm_openr(cmdline.inputFilespec);
pixels = ppm_readppm(ifP, &cols, &rows, &maxval);
pm_close(ifP);
if (cmdline.truecolor)
truecolor = TRUE;
else {
if (cmdline.stdpalette) {
truecolor = FALSE;
generateStandardPalette(&pcxcmap, maxval, &cht, &colors);
} else if (cmdline.palette) {
truecolor = FALSE;
readPaletteFromFile(&pcxcmap, cmdline.palette, maxval,
&cht, &colors);
} else {
bool tooManyColors;
makePcxColormapFromImage(pixels, cols, rows, maxval,
&pcxcmap, &cht, &colors,
&tooManyColors);
if (tooManyColors) {
pm_message("too many colors - writing a 24bit PCX file");
pm_message("if you want a non-24bit file, "
" a 'pnmquant %d'", MAXCOLORS);
truecolor = TRUE;
} else
truecolor = FALSE;
}
}
if (truecolor)
ppmToTruecolorPcx(pixels, cols, rows, maxval,
cmdline.xpos, cmdline.ypos);
else {
ppmToPalettePcx(pixels, cols, rows, maxval,
cmdline.xpos, cmdline.ypos,
pcxcmap, cht, colors, cmdline.packed,
cmdline.planes, cmdline.use_8_bit);
ppm_freecolorhash(cht);
free(pcxcmap);
}
return 0;
}