FloatImg/lib/t.c

307 lines
6.5 KiB
C
Raw Normal View History

2019-09-09 16:02:44 +02:00
/*
* programme de test pour
* les fonctions de base.
*/
2019-06-29 23:50:03 +02:00
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
2019-08-07 11:55:29 +02:00
#include <string.h>
2019-08-08 17:16:20 +02:00
#include <math.h>
2019-06-29 23:50:03 +02:00
#include "../floatimg.h"
int verbosity;
2021-01-14 13:52:04 +01:00
/* ---------------------------------------------------------------- */
int essai_timer(int uuuh)
{
double A, B;
fprintf(stderr, ">>> %s ( %d )\n", __func__, uuuh);
A = fimg_timer_set(uuuh);
sleep(4);
B = fimg_timer_get(uuuh);
fprintf(stderr, " %f %f\n", A, B);
return 0;
}
/* ---------------------------------------------------------------- */
int essai_normalize(void)
{
FloatImg A;
float val;
int foo;
2021-01-14 13:52:04 +01:00
#if 0
foo = fimg_create(&A, 512, 512, FIMG_TYPE_RGB);
if (foo) {
fprintf(stderr, "%s err create A %d\n", __func__, foo);
return foo;
}
fimg_drand48(&A, 255.0);
val = fimg_get_maxvalue(&A);
fprintf(stderr, "BEFORE max pixel %f\n", val);
A.fval = 255.0; A.count = 1;
foo = fimg_normalize(&A, 1.0, 0);
if (foo) {
fprintf(stderr, "%s err normalize A %d\n", __func__, foo);
return foo;
}
val = fimg_get_maxvalue(&A);
fprintf(stderr, "AFTER max pixel %f\n", val);
2020-01-10 12:01:12 +01:00
fimg_destroy(&A);
2021-01-14 13:52:04 +01:00
#endif
2020-01-10 12:01:12 +01:00
return 0;
}
/* ---------------------------------------------------------------- */
#define WI 1024
#define HI 768
#define KDEG 3.141592654 /* secret magic number */
int essai_interpolate(int k)
{
FloatImg A, B, C;
2020-02-16 23:16:38 +01:00
int foo, idx;
char ligne[200];
2020-03-02 01:19:57 +01:00
float fval, minmax[6];
2020-01-10 12:01:12 +01:00
foo = fimg_create(&A, WI, HI, FIMG_TYPE_RGB);
if (foo) {
fprintf(stderr, "%s err create A %d\n", __func__, foo);
return foo;
}
fimg_hdeg_a(&A, KDEG);
foo = fimg_create(&B, WI, HI, FIMG_TYPE_RGB);
if (foo) {
fprintf(stderr, "%s err create B %d\n", __func__, foo);
return foo;
}
fimg_vdeg_a(&B, KDEG);
foo = fimg_create(&C, WI, HI, FIMG_TYPE_RGB);
if (foo) {
fprintf(stderr, "%s err create C %d\n", __func__, foo);
return foo;
}
2020-02-16 23:16:38 +01:00
#define NB 16
for (idx=0; idx<NB; idx++) {
fval = (float)idx / (float)NB;
if (verbosity) fprintf(stderr, "%4d %f\n", idx, fval);
foo = fimg_interpolate(&A, &B, &C, fval);
if (foo) {
fprintf(stderr, "%s err interpolate %d\n", __func__, foo);
return foo;
}
sprintf(ligne, "polate-%02d.pnm", idx);
foo = fimg_save_as_pnm(&C, ligne, 0);
2020-01-10 12:01:12 +01:00
}
2020-02-16 23:16:38 +01:00
/*
$ convert -delay 10 polate-* foo.gif ; animate foo.gif
*/
2020-01-10 12:01:12 +01:00
fimg_destroy(&A); fimg_destroy(&B); fimg_destroy(&C);
return 0;
}
2019-08-24 13:06:51 +02:00
/* ---------------------------------------------------------------- */
int essai_2gray(FloatImg *picz, char *outname)
{
2019-08-26 01:47:05 +02:00
int foo;
FloatImg gray;
2019-08-24 13:06:51 +02:00
2019-08-26 01:47:05 +02:00
fprintf(stderr, ">>> %s ( %p '%s' )\n", __func__, picz, outname);
2019-08-24 13:06:51 +02:00
2019-08-26 01:47:05 +02:00
foo = fimg_create(&gray, picz->width, picz->height, FIMG_TYPE_GRAY);
if (foo) {
fprintf(stderr, "%s : err %d on fimg create\n", __func__, foo);
exit(1);
}
foo = fimg_mk_gray_from(picz, &gray, 0);
if (foo) {
fprintf(stderr, "%s : err %d on fimg mk_gray_from\n", __func__, foo);
exit(1);
}
2019-08-24 13:06:51 +02:00
2019-08-26 01:47:05 +02:00
foo = fimg_save_as_pnm(&gray, outname, 0);
if (foo) {
fprintf(stderr, "%s : err %d on save_as_pnm\n", __func__, foo);
exit(1);
}
fimg_destroy(&gray);
2019-08-24 13:06:51 +02:00
2019-12-27 12:25:33 +01:00
return 0;
}
/* ---------------------------------------------------------------- */
2020-01-10 12:01:12 +01:00
#define TAILLE 1024
2019-12-27 12:25:33 +01:00
int essai_clone_et_copy(int unused)
{
FloatImg A, B, C;
int foo;
2020-01-10 12:01:12 +01:00
foo = fimg_create(&A, TAILLE, TAILLE, FIMG_TYPE_RGB);
2019-12-27 12:25:33 +01:00
if (foo) {
fprintf(stderr, "%s err create A %d\n", __func__, foo);
return foo;
}
foo = fimg_draw_something(&A);
if (foo) {
fprintf(stderr, "%s err drawing A %d\n", __func__, foo);
return foo;
}
2020-01-10 12:01:12 +01:00
foo = fimg_save_as_pnm(&A, "A.pnm", 0);
2019-12-27 12:25:33 +01:00
if (foo) {
fprintf(stderr, "%s : err %d on save_as_pnm\n", __func__, foo);
exit(1);
}
foo = fimg_clone(&A, &B, 1);
if (foo) {
fprintf(stderr, "%s err clone B %d\n", __func__, foo);
return foo;
}
2020-01-10 12:01:12 +01:00
foo = fimg_create(&C, TAILLE, TAILLE, FIMG_TYPE_RGB);
2019-12-27 12:25:33 +01:00
if (foo) {
fprintf(stderr, "%s err create A %d\n", __func__, foo);
return foo;
}
foo = fimg_copy_data(&A, &C);
if (foo) {
fprintf(stderr, "%s err copydata %d\n", __func__, foo);
return foo;
}
foo = fimg_save_as_pnm(&C, "C.pnm", 0);
2020-01-10 12:01:12 +01:00
fimg_destroy(&A); fimg_destroy(&B); fimg_destroy(&C);
2019-12-27 12:25:33 +01:00
2019-08-26 01:47:05 +02:00
return 0;
2019-08-08 17:16:20 +02:00
}
2020-01-10 12:01:12 +01:00
#undef TAILLE
2020-03-02 01:19:57 +01:00
/* ---------------------------------------------------------------- */
int essai_get_values(char *fname)
{
int foo;
FloatImg dessin;
float vals[6];
foo = fimg_create_from_dump(fname, &dessin);
if (foo) {
fprintf(stderr, "in %s, error %d loading '%s'\n",
__func__, foo, fname);
return foo;
}
2020-03-02 14:51:34 +01:00
foo = fimg_get_minmax_rgb(&dessin, vals);
if (foo) {
fprintf(stderr, "%s: err %d on fimg_get_minmax_rgb\n",
__func__, foo);
return foo;
}
2020-03-02 01:19:57 +01:00
for (foo=0; foo<6; foo++) {
fprintf(stderr, "%7d %17.6g\n", foo, vals[foo]);
}
return -1;
}
2019-08-08 17:16:20 +02:00
/* ---------------------------------------------------------------- */
2019-11-12 00:20:28 +01:00
int essai_contraste(char *fname)
{
int foo;
2019-11-12 19:31:00 +01:00
FloatImg dessin, copy;
2019-11-12 00:20:28 +01:00
double maxi;
foo = fimg_create_from_dump(fname, &dessin);
2020-01-10 12:01:12 +01:00
if (foo) {
fprintf(stderr, "in %s, error %d loading '%s'\n",
__func__, foo, fname);
return foo;
}
2019-11-12 19:31:00 +01:00
foo = fimg_clone(&dessin, &copy, 0);
2019-11-12 00:20:28 +01:00
maxi = (double)fimg_get_maxvalue(&dessin);
2020-01-10 12:01:12 +01:00
fprintf(stderr, "image source valeur maxi = %f\n", maxi);
2019-11-12 00:20:28 +01:00
2019-11-12 19:31:00 +01:00
fimg_power_2(&dessin, &copy, maxi);
2019-11-14 14:23:12 +01:00
maxi = (double)fimg_get_maxvalue(&copy);
2020-01-10 12:01:12 +01:00
fprintf(stderr, "apres power_2 valeur maxi = %f\n", maxi);
fimg_save_as_pnm(&copy, "power2.pnm", 0);
2019-11-12 00:20:28 +01:00
2019-11-12 19:31:00 +01:00
fimg_square_root(&dessin, &copy, maxi);
2019-11-14 14:23:12 +01:00
maxi = (double)fimg_get_maxvalue(&copy);
2019-11-12 19:31:00 +01:00
fprintf(stderr, "apres square_root valeur maxi = %f\n", maxi);
2020-01-10 12:01:12 +01:00
fimg_save_as_pnm(&copy, "squareroot.pnm", 0);
2019-11-12 00:20:28 +01:00
2019-11-14 14:23:12 +01:00
fimg_cos_01(&dessin, &copy, maxi);
maxi = (double)fimg_get_maxvalue(&copy);
fprintf(stderr, "apres cos 01 valeur maxi = %f\n", maxi);
2020-01-10 12:01:12 +01:00
fimg_save_as_pnm(&copy, "cos_01.pnm", 0);
2019-11-12 00:20:28 +01:00
2020-01-09 09:28:23 +01:00
fimg_cos_010(&dessin, &copy, maxi);
maxi = (double)fimg_get_maxvalue(&copy);
fprintf(stderr, "apres cos 010 valeur maxi = %f\n", maxi);
2020-01-10 12:01:12 +01:00
fimg_save_as_pnm(&copy, "cos_010.pnm", 0);
2020-01-09 09:28:23 +01:00
2020-01-10 12:01:12 +01:00
fimg_destroy(&dessin); fimg_destroy(&copy);
2019-11-12 00:20:28 +01:00
2020-01-10 12:01:12 +01:00
return 0;
2019-11-12 00:20:28 +01:00
}
2019-09-09 16:02:44 +02:00
/* ---------------------------------------------------------------- */
2019-06-29 23:50:03 +02:00
int main(int argc, char *argv[])
{
int foo, opt;
2019-11-12 00:20:28 +01:00
// char outname[100];
2019-09-10 01:31:48 +02:00
int gray = 0;
while ((opt = getopt(argc, argv, "gn:v")) != -1) {
switch(opt) {
case 'g': gray++; break;
2019-11-12 00:20:28 +01:00
case 'n': foo=atoi(optarg); break;
2019-09-10 01:31:48 +02:00
case 'v': verbosity++; break;
2020-02-16 23:16:38 +01:00
default:
fprintf(stderr, "%s: oh, %c is a bad opt.\n",
argv[0], opt);
exit(5);
2019-09-10 01:31:48 +02:00
}
}
2019-06-29 23:50:03 +02:00
2020-06-11 15:57:12 +02:00
if (verbosity) {
fimg_print_version(1);
fimg_print_sizeof();
}
2019-08-07 11:55:29 +02:00
2020-02-16 23:16:38 +01:00
// foo = essai_normalize();
// fprintf(stderr, "retour essai normalize -> %d\n", foo);
2019-11-12 14:10:45 +01:00
2020-02-16 23:16:38 +01:00
// foo = essai_contraste("quux.fimg");
// fprintf(stderr, "retour essai contraste -> %d\n", foo);
2020-01-10 12:01:12 +01:00
2020-02-16 23:16:38 +01:00
// foo = essai_clone_et_copy(0);
// fprintf(stderr, "retour essai clone'n'copy -> %d\n", foo);
2020-01-10 12:01:12 +01:00
2021-01-14 13:52:04 +01:00
foo = essai_timer(0);
fprintf(stderr, "retour essai -> %d\n", foo);
2020-01-10 12:01:12 +01:00
2019-06-29 23:50:03 +02:00
return 0;
2019-07-08 06:28:04 +02:00
}