int main() {
screen s;
color c;
c.red = MAX_COLOR;
c.green = MAX_COLOR;
c.blue = 0;
clear_screen(s);
int i, j;
for (i=0; i < YRES; i++)
for (j=0; j < XRES; j++ )
plot(s, c, i, j);
c.green = 0;
int counter = 0;
for(counter ; counter < 100 ; counter++) {
draw_line((250 - counter), (250 - (counter * 2)), (150 + (3 * counter)),
(counter * 5), s, c);
}
//Note: Display may not work on your system
//save_ppm and save_extension should be fine
display(s);
save_ppm(s, "pic.ppm");
save_extension(s, "whatevs.png");
}
int main(int c, char *v[]){
if (c != 3) {
printf("Usage: %s input_image output_image\n", v[0]);
} else {
int w, h;
int *x = load_ppm(v[1], &w, &h);
fprintf(stderr, "Got a %dx%d image.\n", w, h);
// some processing here...
// Umbralizado.
int th = 100;
int i;
for (i = 0; i < 3 * w * h; i++) {
if (x[i] <= th) {
x[i] = 0;
} else {
x[i] = 255;
}
}
save_ppm(v[2], x, w, h);
free(x);
return 0;
}
}
int main() {
screen s;
color c;
c.red = MAX_COLOR;
c.green = MAX_COLOR;
c.blue = 0;
clear_screen(s);
int i, j;
for (i=0; i < YRES; i++)
for (j=0; j < XRES; j++)
plot(s, c, i, j);
c.green = 0;
for (i = 0; i<100; i++) {
draw_line(250, 250, 10+i, 10+i, s, c);
}
draw_line(1, 1, 60, 70, s, c);
//Note: Display may not work on your system
//save_ppm and save_extension should be fine
display(s);
save_ppm(s, "pic.ppm");
save_extension(s, "whatevs.png");
}
/*
* Called when keyboard event is received from client.
*/
static void rf_client_keyevent(void)
{
CL_SLOT *cl = (CL_SLOT *)cur_slot;
CARD8 msg[8];
msg[0] = 4; /* KeyEvent */
memcpy(&msg[1], cur_slot->readbuf, 7);
{
const int counter = msg[2] + msg[3] * 255; /* [2..3] is padding */
if (counter) {
crDebug("VNC SPU: marker event %d", counter);
#ifdef NETLOGGER
NL_info("vncspu", "spu.marker", "NUMBER=i", counter);
#endif
#if 0
save_ppm("spuimage.ppm");
#endif
}
}
if (!cl->readonly) {
pass_msg_to_host(msg, sizeof(msg));
}
aio_setread(rf_client_msg, NULL, 1);
}
int main(int argc, char *argv[])
{
XSimple_isp_hp_wrapper ins;
int32_t width = 3280;
int32_t height = 2486;
int32_t channel = 4;
dma_buffer_t ibuf = {.ptr=NULL, .size=width*height*sizeof(uint16_t), .dim=0, .addr=0};
dma_buffer_t obuf = {.ptr=NULL, .size=channel*width*height*sizeof(uint8_t), .dim=0, .addr=0};
const uint16_t optical_black_clamp_value = 16;
const float gamma_value = 1.0f/1.8f;
const float saturation_value = 0.6f;
uint32_t reg_data = 0;
if (argc == 4) {
sscanf(argv[1], "%d", &optical_black_clamp_value);
sscanf(argv[2], "%f", &gamma_value);
sscanf(argv[3], "%f", &saturation_value);
}
if (XSimple_isp_hp_wrapper_Initialize(&ins, "simple_isp_hp_wrapper") != XST_SUCCESS) {
printf("Cannot initialize driver instance\n");
goto finally;
}
pool_t pool;
if (mempool_init(&pool)) goto finally;
if (mempool_alloc(&pool, &ibuf)) goto finally;
if (mempool_alloc(&pool, &obuf)) goto finally;
fill_bayer_pattern(&ibuf, width, height);
memset(obuf.ptr, 0, obuf.size);
XSimple_isp_hp_wrapper_Set_p_in_port_addr_bv_V(&ins, ibuf.addr);
XSimple_isp_hp_wrapper_Set_p_out_port_addr_bv_V(&ins, obuf.addr);
memcpy(®_data, &saturation_value, sizeof(float));
XSimple_isp_hp_wrapper_Set_p_saturation_value(&ins, reg_data);
memcpy(®_data, &optical_black_clamp_value, sizeof(uint16_t));
XSimple_isp_hp_wrapper_Set_p_optical_black_value(&ins, reg_data);
memcpy(®_data, &gamma_value, sizeof(float));
XSimple_isp_hp_wrapper_Set_p_gamma_value(&ins, reg_data);
XSimple_isp_hp_wrapper_Start(&ins);
while (XSimple_isp_hp_wrapper_IsDone(&ins) == 0) {
usleep(10000);
puts(".");
fflush(stdout);
}
save_ppm("out.ppm", (const uint8_t*)obuf.ptr, channel, width, height);
printf("test passed\n");
finally:
mempool_fini(&pool);
XSimple_isp_hp_wrapper_Release(&ins);
return 0;
}
int main() {
screen s;
color c;
c.red = MAX_COLOR;
c.green = MAX_COLOR;
c.blue = 0;
clear_screen(s);
int i, j;
for (i=0; i < YRES; i++)
for (j=-500; j < XRES; j++ )
plot(s, c, i, j);
c.green = 0;
draw_line(0, 0, 400, 350, s, c); //oct 1
draw_line(0, 0, 400, 450, s, c); //oct 2
//draw_line(20, 20, 300, 250, s, c); //oct 5
draw_line(20, 350, 300, 100, s, c); //oct 6
//draw_line(0, 0, 400, 350, s, c);
//draw_line(0, 0, 400, 350, s, c);
//Note: Display may not work on your system
//save_ppm and save_extension should be fine
save_ppm(s, "pic.ppm");
save_extension(s, "whatevs.png");
//display(s);
}
void mmap_read(struct video_config * self, unsigned char *outbuffer, int write_ppm)
{
struct video_mbuf vidbuf;
int numframe = 0;
unsigned char *buffer;
ioctl(self->device_fd, VIDIOCGMBUF, &(vidbuf));
buffer = mmap(NULL, vidbuf.size, PROT_READ, MAP_SHARED, (self->device_fd), 0);
memset(outbuffer, 0, self->vm.width * self->vm.height * 3);
memcpy(outbuffer, buffer, vidbuf.size);
self->vm.format = VIDEO_PALETTE_RGB24;
self->vm.frame = 0;
set_res(self, self->vm.width, self->vm.height);
if(ioctl(self->device_fd, VIDIOCMCAPTURE, &(self->vm)) < 0) {
printf("Error in VIDIOCMCAPTURE\n");
}
if(ioctl(self->device_fd, VIDIOCSYNC, &numframe) < 0) {
printf("Error in VIDIOCSYNC\n");
}
if(write_ppm)
{
save_ppm(self, buffer);
}
}
int main( int argc, char** argv ) {
screen s;
struct matrix *edges;
struct matrix *transform;
color c;
c.red = 200;
c.blue = 150;
c.green = 150;
edges = new_matrix(4, 4);
transform = new_matrix(4, 4);
clear_screen( s );
add_sphere( edges, 250, 250, 50, .01 );
add_torus( edges, 200, 200, 25, 50, .01 );
add_box( edges, 250, 250, 0, 100, 100, 100 );
draw_lines( edges, s, c );
/* if ( argc == 2 )
parse_file( argv[1], transform, edges, s );
else
parse_file( "stdin", transform, edges, s );
*/
display(s);
printf("hi\n");
save_ppm( s, "curves.ppm" );
free_matrix( transform );
free_matrix( edges );
}
int main() {
screen s;
color c;
c.red = MAX_COLOR;
c.green = MAX_COLOR;
c.blue = 0;
clear_screen(s);
int i, j;
for (i=0; i < YRES; i++)
for (j=0; j < XRES; j++ )
plot(s, c, i, j);
c.green = 0;
draw_line(20,20,200,500,s,c); //slope > 1
draw_line(0,0,500,300,s,c); // 0 < slope < 1
draw_line(0,350,350,200,s,c); // -1 < slope < 0
draw_line(0,350,300,0,s,c); // slope < -1
//Note: Display may not work on your system
//save_ppm and save_extension should be fine
display(s);
save_ppm(s, "pic.ppm");
save_extension(s, "whatevs.png");
}
int main() {
screen s;
color c;
c.red = 0;
c.green = 255;
c.blue = 255;
int i, j;
for( i=0; i<XRES; i++)
for ( j=0; j<YRES; j++) {
/*
c.red = random() % (MAX_COLOR + 1);
c.green = random() % (MAX_COLOR + 1);
c.blue = random() % (MAX_COLOR + 1);
*/
c.red= 190;
c.blue =150;
c.green=175;
plot( s, c, i, j);
}
c.blue=255;
c.red =0;
c.green = 150;
printf("Matrix Testing Area. Please stand well out of range of the matrix that is about to happen.\n");
printf("Making a 3X6 matrix.\n\n");
struct matrix* testing = new_matrix(3,6);
add_edge(testing, 1, 11, 1, 2, 12, 1);
add_edge(testing, 3, 13, 1, 4, 14, 1);
add_edge(testing, 5, 15, 1, 6, 16, 1);
printf("Points made. Print test.\n");
print_matrix(testing);
printf("Scalar Multiplication Test:\n");
scalar_mult(3, testing);
print_matrix(testing);
printf("Identity test. Time to face the facts.\n");
struct matrix* identity = new_matrix(6, 6);
ident(identity);
print_matrix(identity);
printf("Testing matrix multiplication. Prepare your eyes. Multiplying by the identity matrix now.\n");
matrix_mult(testing, identity);
print_matrix(identity);
drawPicture(s, c);
display( s );
save_ppm(s, "image" );
save_extension(s, "image.jpg");
}
void save_image ()
{
/* compress and write the jpeg file */
save_ppm(IMAGE_NAME,Image_buffer,User_view.X_size,
User_view.Y_size,255) ;
/* save_jpeg
(IMAGE_NAME,Image_buffer,75,User_view.X_size,User_view.Y_size) ;
*/ printf ("INFO: Saved JPEG file\n") ;
}
int main() {
screen s;
color c;
int x1, y1;
c.red = MAX_COLOR;
c.green = MAX_COLOR;
c.blue = MAX_COLOR;
clear_screen(s);
int i, j;
for (i=0; i < YRES; i++)
for (j=0; j < XRES; j++ )
plot(s, c, i, j);
c.green = 0;
c.blue = 0;
x1 = 500;
y1 = 250;
while (x1 >= 250) {
draw_line(250, 250, x1, y1, s, c);
c.red-=2;
c.green++;
x1--;
y1++;
}
while (y1 >= 250) {
draw_line(250, 250, x1, y1, s, c);
c.green--;
c.blue--;
x1--;
y1--;
}
while (x1 <= 250) {
draw_line(250, 250, x1, y1, s, c);
c.red++;
x1++;
y1--;
}
while (y1 <= 250) {
draw_line(250, 250, x1, y1, s, c);
c.green++;
x1++;
y1++;
}
//Note: Display may not work on your system
//save_ppm and save_extension should be fine
display(s);
save_ppm(s, "pic.ppm");
save_extension(s, "whatevs.png");
}
int main(int argc, char** argv)
{
image_t img;
image_new(&img);
load_ppm("a.ppm", &img);
image_median_filter(&img);
save_ppm("b.ppm", &img);
image_free(&img);
return 0;
}
int main() {
screen s;
color c;
c.red = MAX_COLOR;
c.green = MAX_COLOR;
c.blue = 200;
clear_screen(s);
int i, j;
for (i=0; i < YRES; i++)
for (j=0; j < XRES; j++ )
plot(s, c, i, j);
c.green = 0;
//basic test
/*
draw_line(250,250,250, 500, s, c);
draw_line(250,250,250, 0, s, c);
draw_line(250,250,500, 250, s, c);
draw_line(250,250,0, 250, s, c);
draw_line(250,250,500, 500, s, c);
draw_line(250,250, 0, 500, s, c);
draw_line(250,250,500, 0, s, c);
draw_line(250,250, 0, 0, s, c);*/
int y = 500;
int x = 250;
int counter = 0;
srand(time(NULL));
int r = rand() % 501;
while (counter != 100){
draw_line(x, y, r, r, s, c);
r = rand () %501;
x = rand() % 501;
y = rand()%501;
counter++;
}
//Note: Display may not work on your system
//save_ppm and save_extension should be fine
display(s);
save_ppm(s, "pic.ppm");
save_extension(s, "whatevs.png");
}
int main() {
screen s;
color c;
c.red = 0;
c.green = 0;
c.blue = 0;
clear_screen(s);
int i,j;
for (i=0; i < YRES; i++)
for (j=0; j < XRES; j++ )
plot(s, c, i, j);
for (i=0; i< XRES; i++) {
c.red = i % 256;
c.green = 256 - (i % 256);
c.blue = 0;
draw_line(256, 256, i, 512, s, c);
}
for (i=0; i< XRES; i++) {
c.red = 256 - (i % 256);
c.green = i % 256;
c.blue = 64;
draw_line(256, 256, i, 0, s, c);
}
for (i=0; i< XRES; i++) {
c.red = 0;
c.green = 256 - (i % 256);
c.blue = i % 256;
draw_line(256, 256, 0, i, s, c);
}
for (i=0; i< XRES; i++) {
c.red = i % 256;
c.green = 0;
c.blue = 256 - (i % 256);
draw_line(256, 256, 512, i, s, c);
}
//Note: Display may not work on your system
//save_ppm and save_extension should be fine
display(s);
save_ppm(s, "pic.ppm");
save_extension(s, "whatevs.png");
}
int main() {
fprintf(stderr, "Rendering %zu frames\n", kFramesToRender);
unsigned char *buffer = calloc(4, kWidth * kHeight);
for (size_t i = 0; i < kFramesToRender; ++i) {
trace_scene(i * 0.1f, kWidth, kHeight, buffer, 1);
save_ppm(buffer, kWidth, kHeight, "out_%06u.ppm", i);
fprintf(stderr, " %zu\n", i);
}
return EXIT_SUCCESS;
}
void save_img(std::string filename, const Matrix<Color>& img)
{
std::size_t n = filename.size();
std::string extension3 = filename.substr(n-3, n);
std::string extension4 = filename.substr(n-4, n);
if(!extension3.compare("bmp"))
{
save_bmp(filename, img);
}
else if(!extension3.compare("gif"))
{
save_gif(filename, img);
}
else if(!extension3.compare("ico"))
{
save_ico(filename, img);
}
/*else if(!extension3.compare("jpg"))
{
save_jpeg(filename, img);
}*/
else if(!extension3.compare("pcx"))
{
save_pcx(filename, img);
}
else if(!extension3.compare("png"))
{
save_png(filename, img);
}
else if(!extension3.compare("pbm"))
{
save_pbm(filename, color2bwimage(img));
}
else if(!extension3.compare("pgm"))
{
save_pgm(filename, color2grayimage(img));
}
else if(!extension3.compare("ppm"))
{
save_ppm(filename, img);
}
else if(!extension3.compare("tga"))
{
save_tga(filename, img);
}
else if(!extension4.compare("tiff"))
{
save_tiff(filename, img);
}
}
/* Buffer should be width * height * 3 */
void read_read(struct video_config * self, unsigned char *buffer, int write_ppm)
{
/* unsigned char *buffer; */
int len = 0;
set_res(self,self->vm.width,self->vm.height);
/* buffer = malloc(vm.width * vm.height * 3); */
len = read(self->device_fd, buffer, self->vm.width * self->vm.height * 3);
if(write_ppm)
{
save_ppm(self, buffer);
}
/* free(buffer); */
}
int main() {
screen s;
color c;
c.red = 0;
c.green = 0;
c.blue = 0;
clear_screen(s);
int i, j;
for (i=0; i < YRES; i++)
for (j=0; j < XRES; j++ )
plot(s, c, i, j);
c.green = MAX_COLOR;
c.blue = MAX_COLOR;
c.red = MAX_COLOR;
//too lazy to finish the 2 of hearts
draw_line(90, 1, 410, 1, s, c);
draw_line(90, 499, 410, 499, s, c);
draw_line(90, 1, 90, 499, s, c);
draw_line(410, 1, 410, 499, s, c);
draw_line(110, 480, 140, 480, s, c);
draw_line(140, 480, 140, 460, s, c);
draw_line(140, 460, 110, 445, s, c);
draw_line(110, 445, 110, 425, s, c);
draw_line(110, 425, 140, 425, s, c);
draw_line(360, 20, 390, 20, s, c);
draw_line(360, 20, 360, 40, s, c);
draw_line(360, 40, 390, 55, s, c);
draw_line(390, 55, 390, 75, s, c);
draw_line(360, 75, 390, 75, s, c);
//Note: Display may not work on your system
//save_ppm and save_extension should be fine
display(s);
save_ppm(s, "pic.ppm");
save_extension(s, "whatevs.png");
}
int main() {
screen s;
color c;
c.red = 0;
c.green = 0;
c.blue = 0;
clear_screen(s);
int i, j;
for (i=0; i < YRES; i++)
for (j=0; j < XRES; j++ )
plot(s, c, i, j);
c.red = MAX_COLOR;
//S
draw_line(75, 300, 125, 300, s, c);
draw_line(75, 300, 75, 250, s, c);
draw_line(75, 250, 125, 250, s, c);
draw_line(125, 250, 125, 200, s, c);
draw_line(125, 200, 75, 200, s, c);
//O
draw_line(150, 300, 200, 300, s, c);
draw_line(150, 200, 200, 200, s, c);
draw_line(150, 300, 150, 200, s, c);
draw_line(200, 300, 200, 200, s, c);
//N
draw_line(225, 300, 225, 200, s, c);
draw_line(275, 300, 275, 200, s, c);
draw_line(225, 300, 275, 200, s, c);
//E
draw_line(300, 300, 300, 200, s, c);
draw_line(300, 300, 350, 300, s, c);
draw_line(300, 250, 325, 250, s, c);
draw_line(300, 200, 350, 200, s, c);
//Note: Display may not work on your system
//save_ppm and save_extension should be fine
display(s);
save_ppm(s, "pic.ppm");
save_extension(s, "whatevs.png");
}
static void sample2 (FILE * mpgfile)
{
#define BUFFER_SIZE 4096
uint8_t buffer[BUFFER_SIZE];
mpeg2dec_t * decoder;
const mpeg2_info_t * info;
mpeg2_state_t state;
size_t size;
int framenum = 0;
decoder = mpeg2_init ();
if (decoder == NULL) {
fprintf (stderr, "Could not allocate a decoder object.\n");
exit (1);
}
info = mpeg2_info (decoder);
size = (size_t)-1;
do {
state = mpeg2_parse (decoder);
switch (state) {
case STATE_BUFFER:
size = fread (buffer, 1, BUFFER_SIZE, mpgfile);
mpeg2_buffer (decoder, buffer, buffer + size);
break;
case STATE_SEQUENCE:
mpeg2_convert (decoder, mpeg2convert_rgb24, NULL);
break;
case STATE_SLICE:
case STATE_END:
case STATE_INVALID_END:
if (info->display_fbuf)
save_ppm (info->sequence->width, info->sequence->height,
info->display_fbuf->buf[0], framenum++);
break;
default:
break;
}
} while (size);
mpeg2_close (decoder);
}
int main() {
screen s;
color c;
c.red = 255;
c.green = 0;
c.blue = 0;
int i, j;
for( i=0; i<XRES; i++) {
for ( j=0; j<YRES; j++) {
plot( s, c, i, j);
}
}
c.red = 0;
c.green = 0;
c.blue = 0;
int d = 0;
struct matrix *picture = new_matrix(3,3);
while(d < XRES){
add_edge(picture, d, XRES-d, 1, XRES, d+d, 1);
d++;
}
draw_lines(picture, s, c);
// display( s );
save_ppm(s, "picture.ppm" );
// save_extension(s, "image.jpg");
}
int main() {
screen s;
color c;
c.red = 0;
c.green = 255;
c.blue = 255;
int i, j;
for( i=0; i<XRES; i++)
for ( j=0; j<YRES; j++) {
c.red = random() % (MAX_COLOR + 1);
c.green = random() % (MAX_COLOR + 1);
c.blue = random() % (MAX_COLOR + 1);
plot( s, c, i, j);
}
struct matrix * points = new_matrix(4, 4);
add_point(points, 50, 250, 0);
add_point(points, 70, 250, 0);
add_edge(points, 30, 100, 0, 300, 400, 0);
draw_lines(points, s, c);
print_matrix(points);
printf("\n");
scalar_mult(2.0, points);
printf("\n");
ident(points);
printf("\n");
display( s );
save_ppm(s, "picture" );
save_extension(s, "picture.jpg");
}
static void sample2 (FILE * file)
{
#define BUFFER_SIZE 4096
uint8_t buffer[BUFFER_SIZE];
mpeg2dec_t * mpeg2dec;
const mpeg2_info_t * info;
int state;
int size;
int framenum = 0;
mpeg2dec = mpeg2_init ();
if (mpeg2dec == NULL)
exit (1);
info = mpeg2_info (mpeg2dec);
size = BUFFER_SIZE;
do {
state = mpeg2_parse (mpeg2dec);
switch (state) {
case -1:
size = fread (buffer, 1, BUFFER_SIZE, file);
mpeg2_buffer (mpeg2dec, buffer, buffer + size);
break;
case STATE_SEQUENCE:
mpeg2_convert (mpeg2dec, convert_rgb24, NULL);
break;
case STATE_SLICE:
case STATE_END:
if (info->display_fbuf)
save_ppm (info->sequence->width, info->sequence->height,
info->display_fbuf->buf[0], framenum++);
break;
}
} while (size);
mpeg2_close (mpeg2dec);
}
int main(int argc, char *argv[])
{
unsigned char *image;
unsigned int w, h, bpp, type;
if (argc <= 0)
{
printf("%s filename.png > filename.ppm\n", argv[0]);
}
else
{
if (mtk_image__png_load(argv[1], &image, &w, &h, &bpp, &type) || !image)
{
printf("Error loading image\n");
return -1;
}
save_ppm(image, w, h, type);
delete [] image;
}
return 0;
}
//int main(void)
int main(int argc, char ** argv)
{
int scalefactordefault=100;
int scalefactor=scalefactordefault;
// char nomfich[1000]=
if (argc<2)
{
printf("usage:traj nomlog.data scale\n scale: number of centimeters per pixel of the generated image, default value=100\n");
exit(-1);
}
FILE * f;
//f=fopen("09_11_27__10_52_18.data","rt");
f=fopen(argv[1],"rt");
if (f==NULL)
{
printf("error opening file: %s\n", argv[1]);
exit(-2);
}
if (argc>=3)
{
if (sscanf(argv[2],"%d",&scalefactor)!=1)
scalefactor=scalefactordefault;
}
printf("Using scale: %d cm per pixel\n",scalefactor);
int FrameFound;
int nbGPSFrameFound=0;
double date;
int mode,utm_east,utm_north,course,alt,speed,climb,itow,utm_zone,gps_nb_err;
int utm_north_min=INT_MAX;
int utm_north_max=INT_MIN;
int utm_east_min=INT_MAX;
int utm_east_max=INT_MIN;
int utm_east_delta;
int utm_north_delta;
int nbcameraSnapshotFrameFound=0;
int cameraSnapshotNumber=0;
double phi;
double psi;
double theta;
int nbAttitudeFrameFound=0;
FrameFound=1;
while (FrameFound!=-1) //end of file
{
FrameFound=TryToGetData(f, &date,&mode,&utm_east,&utm_north,&course,&alt,&speed,&climb,&itow,&utm_zone,&gps_nb_err,&cameraSnapshotNumber,&phi,&psi,&theta); //gps position in utm in cm
//GPSFrameFound=TryToGetNavigatioData(f, &utm_east,&utm_north); //it is not utm position but xy position from home in m
//printf("FrameFound:%d\n",FrameFound);
switch (FrameFound)
{
case 1:
nbGPSFrameFound++;
//printf("%d\n",nbGPSFrameFound);
//check that we stay in the same utm zone
if (utm_north_min>utm_north)
utm_north_min=utm_north;
if (utm_north_max<utm_north)
utm_north_max=utm_north;
if (utm_east_min>utm_east)
utm_east_min=utm_east;
if (utm_east_max<utm_east)
utm_east_max=utm_east;
break;
case 2:
nbcameraSnapshotFrameFound++;
//printf("C:%d\n" ,nbcameraSnapshotFrameFound);
break;
case 3:
nbAttitudeFrameFound++;
//printf("C:%d\n" ,nbcameraSnapshotFrameFound);
break;
}
}
printf("------------------------------------------------------------------------------\n");
printf("nbGPSFrameFound: %d\n\n",nbGPSFrameFound);
printf("nbcameraSnapshotFrameFound: %d\n\n",nbcameraSnapshotFrameFound);
printf("nbAttitudeFrameFound: %d\n\n",nbAttitudeFrameFound);
printf("utm_east_min: %d\n",utm_east_min);
printf("utm_east_max: %d\n",utm_east_max);
printf("utm_north_min: %d\n",utm_north_min);
printf("utm_north_max: %d\n",utm_north_max);
utm_east_delta=utm_east_max-utm_east_min;
utm_north_delta=utm_north_max-utm_north_min;
printf("utm_east_delta: %d\n",utm_east_delta);
printf("utm_north_delta: %d\n",utm_north_delta);
//utm are expressed in cm
if ((( utm_east_delta>0) && (utm_north_delta>0) ) )
{
printf("------------------------------------------------------------------------------\n");
printf("generating image\n");
im_color * im_traj;
/* allocates an image of size xd*yd pixels */
im_traj=alloc_im_color(utm_east_delta/scalefactor,utm_north_delta/scalefactor);
memset(im_traj->data,255,im_traj->xd*im_traj->yd*3);
rewind (f);
rgb col;
col.r=255;
col.g=0;
col.b=0;
FrameFound=1;
while (FrameFound!=-1) //end of file
{
FrameFound=TryToGetData(f,&date, &mode,&utm_east,&utm_north,&course,&alt,&speed,&climb,&itow,&utm_zone,&gps_nb_err,&cameraSnapshotNumber,&phi,&psi,&theta);
//GPSFrameFound=TryToGetNavigatioData(f, &utm_east,&utm_north); //it is not utm position but xy position from home in m
//printf("FrameFound:%d\n",FrameFound);
switch (FrameFound)
{
case 1:
int xd=(utm_east-utm_east_min)/scalefactor;
int yd=im_traj->yd-(utm_north-utm_north_min)/scalefactor;
// printf("xd: %d, yd:%d\n",xd,yd);
// set_color_pixel_with_boundaries(im_traj,xd,yd,&col);
draw_square(im_traj,xd,yd,&col,200/scalefactor);
break;
case 2:
if (cameraSnapshotNumber==0)
{
col.r=255;
col.g=0;
col.b=0;
//printf("R");
}
else
{
col.b=255;
col.r=0;
col.g=0;
//printf("B");
}
break;
}
}
save_ppm("im_traj.ppm",im_traj);
dealloc_im_color(im_traj);
printf("------------------------------------------------------------------------------\n");
printf("converting image\n");
char chainecommande[10000];
sprintf(chainecommande,"convert im_traj.ppm %s.png",argv[1]);
//system("convert im_traj.ppm im_traj.png");
system(chainecommande);
printf("------------------------------------------------------------------------------\n");
printf("erasing temporary image\n");
sprintf(chainecommande,"rm im_traj.ppm");
system(chainecommande);
// std::cout << "Bye, world!\n";
}
else
{
printf("empty log?\n");
}
printf("------------------------------------------------------------------------------\n");
fclose(f);
return 0;
}
int main() {
screen s;
color c;
c.red = 50;
c.green = 200;
c.blue = 54;
clear_screen(s);
int i, j;
for (i=0; i < YRES; i++)
for (j=0; j < XRES; j++ )
plot(s, c, i, j);
c.green = 0;
c.red = 0;
c.blue=0;
// draw_line(20, 350, 300, 350, s, c); //oct 6
i = 0;
for(i;i<100;i++){
draw_line(i,0,i,500,s,c);
c.red = c.red +1;
}
c.red=0;
i = 100;
for(i;i<200;i++){
draw_line(i,0,i,500,s,c);
c.red = c.red +1;
}
c.red=0;
i = 200;
for(i;i<300;i++){
draw_line(i,0,i,500,s,c);
c.red = c.red +1;
}
c.red=0;
i = 300;
for(i;i<400;i++){
draw_line(i,0,i,500,s,c);
c.red = c.red +1;
}
c.red=0;
i = 400;
for(i;i<500;i++){
draw_line(i,0,i,500,s,c);
c.red = c.red +1;
}
c.red = 255;
c.green = 255;
c.blue = 0;
i = 0;
for(i;i<100;i++){
draw_line(i,0,500,500,s,c);
draw_line(0,i,500,500,s,c);
draw_line(500-i,0,0,500,s,c);
draw_line(500,i,0,500,s,c);
}
c.red = 0;
c.green = 0;
draw_line(0,100,500,500,s,c);
draw_line(100,0,500,500,s,c);
//Note: Display may not work on your system
//save_ppm and save_extension should be fine
//display(s);
save_ppm(s, "pic.ppm");
save_extension(s, "whatevs.png");
}
int main() {
screen s;
color c;
c.red = 0;
c.green = 0;
c.blue = 0;
clear_screen(s);
int i, j;
for (i=0; i < YRES; i++)
for (j=0; j < XRES; j++ )
plot(s, c, i, j);
c.green = MAX_COLOR;
draw_line(250, 0, 250, 500, s, c);
draw_line(125, 0, 375, 500, s, c);
draw_line(0, 0, 500, 500, s, c);
draw_line(0, 125, 500, 375, s, c);
draw_line(0, 250, 500, 250, s, c);
draw_line(0, 375, 500, 125, s, c);
draw_line(0, 500, 500, 0, s, c);
draw_line(125, 500, 375, 0, s, c);
/* c.green = 0;
c.red = MAX_COLOR;
draw_line(125, 0, 125, 250, s, c);
draw_line(62, 0, 187, 250, s, c);
draw_line(0, 0, 250, 250, s, c);
draw_line(0, 62, 250, 187, s, c);
draw_line(0, 125, 250, 125, s, c);
draw_line(0, 187, 250, 62, s, c);
draw_line(0, 250, 250, 0, s, c);
draw_line(62, 250, 187, 0, s, c);
c.red = 0;
c.blue = MAX_COLOR;
draw_line(375, 0, 375, 250, s, c);
draw_line(312, 0, 427, 250, s, c);
draw_line(250, 0, 500, 250, s, c);
draw_line(250, 62, 500, 187, s, c);
draw_line(250, 125, 500, 125, s, c);
draw_line(250, 187, 500, 62, s, c);
draw_line(250, 250, 500, 0, s, c);
draw_line(312, 250, 427, 0, s, c);
c.red = MAX_COLOR;
draw_line(125, 250, 125, 500, s, c);
draw_line(62, 250, 187, 500, s, c);
draw_line(0, 250, 250, 500, s, c);
draw_line(0, 312, 250, 427, s, c);
draw_line(0, 375, 500, 375, s, c);
draw_line(0, 427, 250, 312, s, c);
draw_line(0, 500, 250, 250, s, c);
draw_line(62, 500, 187, 250, s, c);
c.blue = 0;
c.green = MAX_COLOR;
draw_line(375, 250, 375, 500, s, c);
draw_line(312, 250, 427, 500, s, c);
draw_line(250, 500, 500, 250, s, c);
draw_line(250, 312, 500, 427, s, c);
draw_line(250, 375, 500, 375, s, c);
draw_line(250, 427, 500, 312, s, c);
draw_line(250, 250, 500, 500, s, c);
draw_line(312, 500, 427, 250, s, c);
*/
//Note: Display may not work on your system
//save_ppm and save_extension should be fine
//display(s);
save_ppm(s, "pic.ppm");
save_extension(s, "whatevs.png");
}
int main() {
//Basic Matrix Math
struct matrix *a;
struct matrix *b;
a=new_matrix(4,4);
b=new_matrix(4,2);
printf("Identity matrix:\n");
ident(a);
print_matrix(a);
b->m[0][0]=1;
b->m[0][1]=2;
b->m[1][0]=3;
b->m[1][1]=4;
b->m[2][0]=5;
b->m[2][1]=6;
b->m[3][0]=7;
b->m[3][1]=8;
printf("Matrix #2:\n");
print_matrix(b);
printf("Scalar Multiplication by 2:\n");
scalar_mult(2, b);
print_matrix(b);
printf("New Matrix #1:\n");
a->m[2][1]=3;
a->m[0][3]=2;
print_matrix(a);
printf("Matrix Multiplication:\n");
matrix_mult(a, b);
print_matrix(b);
printf("Adding points/edges:\n");
struct matrix *d;
d = new_matrix(3, 3);
add_point(d, 200,400,70);
add_point(d, 200,0,7);
print_matrix(d);
printf("\n");
add_edge(d, 300,500,100,300,100,134);
add_edge(d, 100,500,100,100,100,134);
add_edge(d, 400,00,100,400,400,134);
print_matrix(d);
printf("\n");
screen s;
color c;
c.red = 200;
c.green = 100;
c.blue = 250;
int i, j;
for( i=0; i<XRES; i++)
for ( j=0; j<YRES; j++) {
plot( s, c, i, j);
}
c.red=0;
c.green=200;
c.blue=200;
draw_lines(d, s, c);
display( s );
save_ppm(s, "image" );
save_extension(s, "image.jpg");
}
int main() {
screen s;
color c;
// TEST: add_point
struct matrix *a;
a = (struct matrix *)new_matrix(3,3);
add_point(a,1,0,2);
// TEST: print_matrix
printf("\nAdding one point to matrix A:\n");
print_matrix(a);
// TEST: add_edge
add_edge(a,4,5,3,2,2,2);
printf("Adding an edge:\n");
print_matrix(a);
// TEST: scalar multiplication
scalar_mult(5,a);
printf("Scalar multiplication by 5:\n");
print_matrix(a);
scalar_mult(0.2,a);
printf("Scalar multiplication by 0.2, returning to original matrix:\n");
print_matrix(a);
// TEST: matrix matrix multiplication
struct matrix *b;
b = (struct matrix *)new_matrix(3,1);
add_point(b,1,2,3);
printf("Matrix B:\n");
print_matrix(b);
matrix_mult(a,b);
printf("Matrix multiplication of A with B:\n");
print_matrix(a);
// TEST: turning a matrix into the identity matrix
struct matrix *d;
d = (struct matrix *)new_matrix(3,3);
add_edge(d,3,4,5,8.2,9.1,2);
add_point(d,5,2,1);
printf("Matrix C:\n");
print_matrix(d);
ident(d);
printf("Matrix C after being made into the 3 x 3 identity matrix:\n");
print_matrix(d);
/*
struct matrix *m;
m = (struct matrix *)new_matrix(3,3);
m->m[0][0] = 1;
m->m[0][1] = 2;
m->m[0][2] = 5;
m->m[1][0] = 3;
m->m[1][1] = 4;
m->m[1][2] = 6;
m->m[2][0] = 7;
m->m[2][1] = 8;
m->m[2][2] = 9;
*/
/*
struct matrix *n;
n = (struct matrix *)new_matrix(3,4);
n->m[0][0] = 1;
n->m[1][0] = 2;
n->m[2][0] = 1;
n->m[0][1] = 1;
n->m[1][1] = 0;
n->m[2][1] = 1;
n->m[0][2] = 1;
n->m[1][2] = 2;
n->m[2][2] = 1;
n->m[0][3] = 1;
n->m[1][3] = 1;
n->m[2][3] = 0;
*/
/*
struct matrix *p;
p = (struct matrix *)new_matrix(3,5);
p->m[0][0] = 1;
//print_matrix(p);
//print_matrix(matrix_mult(m,n));
*/
/*
struct matrix *q;
q = (struct matrix *)new_matrix(3,2);
add_point(q,0,0,0);
add_point(q,100,0,0);
struct matrix *t;
t = (struct matrix *)new_matrix(3,3);
t->m[0][0] = cos(M_PI / 6);
t->m[1][0] = sin(M_PI / 6);
t->m[0][1] = -1 * sin(M_PI / 6);
t->m[1][1] = cos(M_PI / 6);
t->lastcol = 2;
*/
/*add_edge(t,cos( M_PI / 6),sin( M_PI / 6), 0,
-1 * sin(M_PI / 6), cos(M_PI / 6), 0);
*/
/*
struct matrix *u;
u = (struct matrix *)new_matrix(3,2);
add_edge(u,0,0,0,100,0,0);
int i;
for(i = 0; i < 11; i++){
matrix_mult(t,q);
add_edge(u,q->m[0][0],q->m[1][0],q->m[2][0],
q->m[0][1],q->m[1][1],q->m[2][1]);}
int j,k;
float f;
for(j = 0; j < u->rows; j++){
for(k = 0; k < u->cols; k++){
f = u->m[j][k];
u->m[j][k] = (int)f + 250;}
}
print_matrix(t);
printf("%f\n", cos(M_PI / 6));
*/
/*
struct matrix *r;
r = (struct matrix *)new_matrix(3,2);
r->m[0][0] = 0;
r->m[0][1] = 0;
r->m[1][0] = 50;
r->m[1][1] = 50;
print_matrix(m);
matrix_mult(m,q);
print_matrix(m);
*/
/*
int i,j;
c.red = 0;
c.green = 0;
c.blue = 255;
for(i = 0; i < XRES; i++){
for(j = 0; j < YRES; j++){
plot(s,c,i,j);
}
}
c.red = 0;
c.green = 0;
c.blue = 0;
draw_lines(q,s,c);
*/
/*
int i, j;
for( i=0; i<XRES; i++)
for ( j=0; j<YRES; j++) {
c.red = random() % (MAX_COLOR + 1);
c.green = random() % (MAX_COLOR + 1);
c.blue = random() % (MAX_COLOR + 1);
plot( s, c, i, j);
}
*/
c.red = 170;
c.green = 240;
c.blue = 30;
int i,j;
for(i = 0; i < XRES; i++){
for(j = 0; j < YRES; j++){
plot(s,c,i,j);
}
}
// TEST: draw lines in edge matrix
c.red = 0;
c.green = 0;
c.blue = 0;
struct matrix *e;
e = (struct matrix *)new_matrix(3,2);
//add_point(e,0,0,0);
//add_point(e,250,250,0);
//draw_lines(e,s,c);
for(i = 0; i < 25; i++){
add_edge(e,250+5*i,250+5*i,0,500-5*i,250+5*i,0);
add_edge(e,500-5*i,250+5*i,0,500-5*i,500-5*i,0);
//add_edge(e,500-5*i,500-5*i,0,250+5*i,250+5*i,0);
}
for(i = 0; i < 25; i++){
add_edge(e,5*i,5*i,0,250-5*i,5*i,0);
add_edge(e,250-5*i,5*i,0,250-5*i,250-5*i,0);
//add_edge(e,250-5*i,250-5*i,0,5*i,5*i,0);
}
for(i = 0; i < 25; i++){
add_edge(e,125+5*i,125+5*i,0,125+5*i,375-5*i,0);
add_edge(e,125+5*i,375-5*i,0,375-5*i,375-5*i,0);
//add_edge(e,375-5*i,375-5*i,0,125+5*i,125+5*i,0);
}
add_edge(e,0,0,0,125,125,0);
add_edge(e,375,375,0,500,500,0);
draw_lines(e,s,c);
display( s );
save_ppm(s, "image" );
save_extension(s, "image.jpg");
}
