FloatImg4PythonBinding/Fonderie/crapulator.c

411 lines
8.2 KiB
C
Raw Normal View History

2020-11-02 01:25:00 +01:00
/*
* crapulator.c
*/
#include <stdio.h>
#include <stdlib.h>
2021-05-20 09:31:28 +02:00
#include <stdint.h>
2020-12-30 14:42:44 +01:00
#include <string.h>
#include <unistd.h>
2020-11-02 01:25:00 +01:00
2021-01-25 17:18:44 +01:00
#include "../floatimg.h"
2020-11-02 01:25:00 +01:00
2021-04-02 19:25:20 +02:00
#include "fifo.h"
2020-11-02 01:25:00 +01:00
#include "crapulator.h"
2020-11-16 11:12:29 +01:00
#include "glitches.h"
2020-12-02 19:55:06 +01:00
#include "sfx.h"
2020-11-02 01:25:00 +01:00
2021-02-23 03:49:24 +01:00
extern int verbosity;
2021-01-11 22:22:03 +01:00
/* -------------------------------------------------------------- */
static int trier_les_pixels(FloatImg *pimg)
{
FloatImg copy;
int foo;
fimg_clone(pimg, &copy, 1);
2021-01-13 16:09:27 +01:00
foo = fimg_qsort_rgb_a(pimg, &copy, 0);
2021-01-11 22:22:03 +01:00
if (foo) {
fprintf(stderr, "%s: err qsort rgb = %d\n", __func__, foo);
return foo;
}
2021-03-29 11:59:24 +02:00
incrustation_vignette(pimg, &copy, 0);
2021-01-11 22:22:03 +01:00
fimg_copy_data(&copy, pimg);
fimg_destroy(&copy);
return 0;
}
2020-11-04 10:41:21 +01:00
/* -------------------------------------------------------------- */
static int effect_3(FloatImg *image)
{
float value;
int foo;
value = fimg_get_maxvalue(image);
fimg_mul_cste(image, -1.0);
fimg_add_cste(image, value);
foo = fimg_count_negativ(image);
if (foo) {
fimg_dump_to_file(image, "err.fimg", 0);
fprintf(stderr, "%s negativ %d\n",
__func__, foo);
return -78;
}
return 0;
}
/* -------------------------------------------------------------- */
static int insitu_ctr2x2(FloatImg *pimg)
{
FloatImg img;
int retval;
fimg_clone(pimg, &img, 0);
retval = fimg_contour_2x2(pimg, &img, 0);
if (retval) {
fprintf(stderr, "%s : err contour %d\n",
__func__, retval);
exit(1);
}
fimg_copy_data(&img, pimg);
fimg_destroy(&img);
return 0;
}
2020-11-02 01:25:00 +01:00
/* -------------------------------------------------------------- */
2020-12-19 10:19:18 +01:00
static int insitu_filtre3x3(FloatImg *pimg, int typef)
2020-12-03 11:47:44 +01:00
{
FloatImg img;
2021-02-23 03:49:24 +01:00
int foo, retval;
2020-12-19 10:19:18 +01:00
FimgFilter3x3 *pfiltre;
2020-12-03 11:47:44 +01:00
2020-12-19 10:19:18 +01:00
FimgFilter3x3 lowpass = {
2020-12-03 11:47:44 +01:00
{
1.0, 2.0, 1.0,
2.0, 4.0, 2.0,
1.0, 2.0, 1.0,
},
16.0, 0.0
};
2020-12-19 10:19:18 +01:00
FimgFilter3x3 hipass = {
{
-1.0, -1.0, -1.0,
-1.0, 9.0, -1.0,
-1.0, -1.0, -1.0,
},
1.0, 0.0
};
2021-02-23 03:22:14 +01:00
FimgFilter3x3 diagonal = {
{
2.0, 1.0, 0.0,
1.0, 0.0, -1.0,
0.0, -1.0, -2.0,
},
2021-02-25 11:39:36 +01:00
1.0, 0.0
2021-02-23 03:22:14 +01:00
};
2020-12-19 10:19:18 +01:00
switch (typef) {
case 0: pfiltre = &lowpass; break;
case 1: pfiltre = &hipass; break;
2021-02-23 03:22:14 +01:00
case 2: pfiltre = &diagonal; break;
2020-12-19 10:19:18 +01:00
default:
fprintf(stderr, "%s: bad filter number %d\n",
__func__, typef);
return -6;
break;
}
2020-12-03 11:47:44 +01:00
fimg_clone(pimg, &img, 0);
2020-12-19 10:19:18 +01:00
retval = fimg_filter_3x3(pimg, &img, pfiltre);
2020-12-03 11:47:44 +01:00
if (retval) {
fprintf(stderr, "%s error %d on filter\n", __func__, retval);
exit(1);
}
2021-02-25 11:39:36 +01:00
(void)fimg_killborders(&img); /* nice try ? */
2021-02-24 12:35:31 +01:00
foo = fimg_auto_shift_to_zero(&img, &img);
if (foo) {
fprintf(stderr, "%s: err %d zero shift\n", __func__, foo);
exit(1);
}
2021-02-23 03:49:24 +01:00
/** may be, we can check for negative values ? */
2021-02-24 12:35:31 +01:00
/** or is this useless because whe have shifted to zero ? */
2021-02-23 11:23:59 +01:00
if (verbosity > 1) {
2021-02-23 03:49:24 +01:00
foo = fimg_count_negativ(&img);
2021-02-24 12:35:31 +01:00
if (foo) {
fprintf(stderr, "%s -> %d / %d negative pixels\n", __func__,
foo, img.width*img.height);
}
2021-02-23 03:49:24 +01:00
}
2021-02-23 03:22:14 +01:00
fimg_killborders(&img);
2020-12-03 11:47:44 +01:00
fimg_copy_data(&img, pimg);
fimg_destroy(&img);
return retval;
}
/* -------------------------------------------------------------- */
2020-11-03 00:00:09 +01:00
/*
2020-12-07 12:52:17 +01:00
* This is the main filter engine used both for input and
* output processing. It can be called by the filterstack
* processor.
2020-11-03 00:00:09 +01:00
*/
2020-11-20 22:25:30 +01:00
2021-05-11 10:36:55 +02:00
#define DEBUG_THIS_CRAP 0
2020-11-20 22:25:30 +01:00
2020-11-02 14:51:48 +01:00
int crapulator(FloatImg *image, int idFx, float fval)
2020-11-02 01:25:00 +01:00
{
2020-11-05 21:07:38 +01:00
int retval;
// FloatImg imgtmp;
2020-11-02 01:25:00 +01:00
#if DEBUG_LEVEL
2020-11-02 14:51:48 +01:00
fprintf(stderr, ">>> %s ( %p %d %f )\n", __func__,
image, idFx, fval);
2020-11-02 01:25:00 +01:00
#endif
2020-11-20 22:25:30 +01:00
#if DEBUG_THIS_CRAP
2020-12-03 11:47:44 +01:00
static int count = 0;
int flag_debug = 0;
2021-04-02 04:16:26 +02:00
if (DEBUG_THIS_CRAP==count) {
2020-11-02 14:51:48 +01:00
flag_debug = 1;
2020-11-02 22:20:54 +01:00
fprintf(stderr, "DEBUG PT 1 in %s:%d\n", __func__, __LINE__);
2020-11-03 00:00:09 +01:00
fimg_save_as_png(image, "crap_before.png", 0);
2020-11-02 14:51:48 +01:00
}
2020-11-20 22:25:30 +01:00
#endif
2020-11-02 14:51:48 +01:00
2021-01-08 22:57:45 +01:00
retval = 0;
2020-11-02 14:51:48 +01:00
switch (idFx) {
2020-12-30 14:42:44 +01:00
case CR_none: /* DO NOTHING */
2021-04-02 04:16:26 +02:00
retval = 0;
break;
2020-12-30 14:42:44 +01:00
case CR_cos01:
2020-11-02 14:51:48 +01:00
fimg_cos_01(image, image,
fimg_get_maxvalue(image));
break;
2020-12-30 14:42:44 +01:00
case CR_cos010:
2020-11-02 14:51:48 +01:00
fimg_cos_010(image, image,
fimg_get_maxvalue(image));
break;
2020-12-30 14:42:44 +01:00
case CR_fx3:
2020-11-04 10:41:21 +01:00
retval = effect_3(image);
2020-11-02 14:51:48 +01:00
break;
2020-12-30 14:42:44 +01:00
case CR_rnd48a:
2020-11-02 14:51:48 +01:00
brotche_rand48_a(image, 0.20,
fimg_get_maxvalue(image));
break;
2020-12-30 14:42:44 +01:00
case CR_rnd48b:
2020-11-02 14:51:48 +01:00
brotche_rand48_b(image, 0.10,
fimg_get_maxvalue(image)*0.8);
break;
2020-12-30 14:42:44 +01:00
case CR_killcola:
2020-12-07 12:52:17 +01:00
retval = fimg_killcolors_a(image, 0.0);
2020-11-02 14:51:48 +01:00
break;
2020-12-30 14:42:44 +01:00
case CR_colmixa:
2020-11-02 14:51:48 +01:00
retval = fimg_colors_mixer_a(image, 2.0);
break;
2020-12-30 14:42:44 +01:00
case CR_ctr2x2:
2020-11-04 10:41:21 +01:00
retval = insitu_ctr2x2(image);
2020-11-02 14:51:48 +01:00
break;
2020-12-30 14:42:44 +01:00
case CR_classtrial:
2020-11-02 22:20:54 +01:00
retval = fimg_classif_trial(image, image, 0.37, 0);
2020-11-02 14:51:48 +01:00
break;
2020-12-30 14:42:44 +01:00
case CR_binarize:
2021-03-21 05:08:35 +01:00
retval = fimg_binarize(image, 0);
2020-11-05 21:07:38 +01:00
break;
2020-12-30 14:42:44 +01:00
case CR_trinarize:
2021-03-26 05:40:45 +01:00
retval = fimg_trinarize(image, 0);
2020-11-10 00:50:25 +01:00
break;
2020-12-30 14:42:44 +01:00
case CR_liss2x2:
2020-12-02 19:55:06 +01:00
retval = fimg_lissage_2x2(image);
2021-02-23 03:49:24 +01:00
// (void)fimg_killborders(image);
2020-12-02 19:55:06 +01:00
break;
2020-12-30 14:42:44 +01:00
case CR_liss3x3:
2020-12-24 10:28:56 +01:00
/* smooth filter */
2020-12-19 10:19:18 +01:00
retval = insitu_filtre3x3(image, 0);
2020-12-03 11:47:44 +01:00
break;
2020-12-30 14:42:44 +01:00
case CR_desaturate:
2020-12-20 13:19:35 +01:00
retval = fimg_desaturate(image, image, 0);
2020-12-07 12:52:17 +01:00
break;
2020-12-30 14:42:44 +01:00
case CR_killlines:
2020-12-08 15:51:07 +01:00
retval = kill_a_few_lines(image, fval,
2021-05-05 10:21:47 +02:00
image->height/19);
2020-12-08 15:51:07 +01:00
break;
2020-12-30 14:42:44 +01:00
case CR_water:
2021-01-13 16:09:27 +01:00
retval = bouger_les_pixels(image, 12);
2020-12-10 19:19:35 +01:00
break;
2020-12-30 14:42:44 +01:00
case CR_mirsplit:
2020-12-10 19:19:35 +01:00
retval = mirror_split(image, 0);
break;
2020-12-30 14:42:44 +01:00
case CR_updown:
2020-12-18 10:18:09 +01:00
retval = upside_down(image);
break;
2020-12-30 14:42:44 +01:00
case CR_hipass:
2020-12-24 10:28:56 +01:00
/* hipass filter */
2020-12-19 10:19:18 +01:00
retval = insitu_filtre3x3(image, 1);
break;
2021-02-23 03:22:14 +01:00
case CR_diagonal:
retval = insitu_filtre3x3(image, 2);
break;
2020-12-30 14:42:44 +01:00
case CR_octotree:
2020-12-29 12:56:26 +01:00
retval = octotree_classif(image, 0.500, 0);
2020-12-29 00:54:15 +01:00
break;
2021-01-03 15:21:38 +01:00
case CR_trinitron:
retval = trinitron(image, 0);
break;
2020-12-07 12:52:17 +01:00
2021-05-08 21:57:10 +02:00
case CR_sqrt:
retval = fimg_square_root(image, image, 1000.0);
break;
case CR_pow2:
retval = fimg_power_2(image, image, 1000.0);
break;
2021-05-29 23:29:13 +02:00
case CR_triplemul:
retval = fimg_sfx_triplemul(image, image, 0);
break;
2020-12-07 12:52:17 +01:00
/* here are the glitches */
2020-12-30 14:42:44 +01:00
case CR_bsombra: /* experiment ! */
2020-11-25 10:32:02 +01:00
retval = des_bords_sombres_a(image, 160);
2020-11-20 22:25:30 +01:00
break;
2021-05-11 10:36:55 +02:00
case CR_bsombrb: /* experiment ! */
retval = des_bords_sombres_b(image, 160);
break;
2020-12-30 14:42:44 +01:00
case CR_vsglitch:
2020-11-18 11:47:26 +01:00
/* please make this function more tweakable */
2020-12-02 19:55:06 +01:00
retval = vertical_singlitch(image, 290+rand()%45,
2020-12-30 14:42:44 +01:00
fval, 0.19, 0);
2020-11-15 11:47:37 +01:00
break;
2020-12-20 11:12:43 +01:00
2021-06-01 10:26:39 +02:00
case CR_crumphard: /* new june 1st 2021, in the bibcave */
retval = fimg_crump_hard(image, image, fval, 0);
break;
2020-12-30 14:42:44 +01:00
case CR_rndblks:
2020-12-23 16:40:45 +01:00
retval = random_blocks(image, 70);
2020-12-20 11:12:43 +01:00
break;
2020-12-31 00:46:12 +01:00
case CR_shiftln0:
retval = multilines_shift_0(image, 11, 120);
break;
2021-01-10 16:40:49 +01:00
case CR_qsortrgb:
2021-01-11 22:22:03 +01:00
retval = trier_les_pixels(image);
2021-01-10 16:40:49 +01:00
break;
2021-01-16 11:29:40 +01:00
case CR_multidots:
retval = plot_multidots(image, 42);
break;
2020-12-30 14:42:44 +01:00
case CR_message:
2021-01-10 16:40:49 +01:00
fprintf(stderr, "### msg from pid %d, fval=%f ###\n",
2020-12-30 14:42:44 +01:00
getpid(), fval);
2021-05-10 00:05:01 +02:00
/* here, we can display stats ! */
fimg_describe(image, "in crapulator");
2020-12-30 14:42:44 +01:00
retval = 0;
break;
2021-01-03 15:21:38 +01:00
case CR_nothing:
retval = do_something(image, 3);
break;
2021-03-20 20:32:25 +01:00
case CR_hilightr:
retval = fimg_highlight_color(image, image, 'R', 1.717);
break;
2020-11-02 14:51:48 +01:00
default :
fprintf(stderr, "%s : effect #%d invalid\n",
__func__, idFx);
return -77;
}
2020-11-02 01:25:00 +01:00
2020-11-20 22:25:30 +01:00
#if DEBUG_THIS_CRAP
2020-11-02 14:51:48 +01:00
if (flag_debug) {
2020-11-02 22:20:54 +01:00
fprintf(stderr, "DEBUG PT 2 in %s:%d\n", __func__, __LINE__);
2020-11-03 00:00:09 +01:00
fimg_save_as_png(image, "crap_after.png", 0);
2020-11-20 22:25:30 +01:00
flag_debug = 0;
2020-11-02 01:25:00 +01:00
}
2020-11-20 22:25:30 +01:00
count++;
2020-12-03 11:47:44 +01:00
#endif
2020-11-02 01:25:00 +01:00
2020-11-02 14:51:48 +01:00
return retval;
2020-11-02 01:25:00 +01:00
}
2020-12-19 10:19:18 +01:00
/* -------------------------------------------------------------- */
typedef struct {
int id;
char *name;
int ipar;
float fpar;
int flags;
} Crapulor;
2021-04-02 04:16:26 +02:00
/* Warning: overengeniring inside */
#include "crapstr.h" /* generated file ! */
2020-12-29 16:40:26 +01:00
#define NBCRAP (sizeof(CrapL)/sizeof(Crapulor))
void list_crapulors(char *texte)
{
int idx;
2020-12-30 14:42:44 +01:00
#define OUT stdout
fprintf(OUT, "______________. %s\n", texte);
for (idx=0; CrapL[idx].id!=-1; idx++) {
fprintf(OUT, " %-12s | %4d | %5d | %8.3f\n",
2020-12-29 16:40:26 +01:00
CrapL[idx].name,
2020-12-30 14:42:44 +01:00
CrapL[idx].id,
2020-12-29 16:40:26 +01:00
CrapL[idx].ipar,
CrapL[idx].fpar);
}
2020-12-30 14:42:44 +01:00
#undef OUT
2020-12-29 16:40:26 +01:00
}
2020-11-10 19:30:49 +01:00
/* -------------------------------------------------------------- */
char * crap_name_from_number(int num)
{
2020-12-30 14:42:44 +01:00
int idx;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( %d )\n", __func__, num);
#endif
for (idx=0; CrapL[idx].id!=-1; idx++) {
if (num == CrapL[idx].id) {
return CrapL[idx].name;
}
2020-12-15 17:49:12 +01:00
}
2020-11-02 01:25:00 +01:00
2020-11-10 19:30:49 +01:00
return "???";
}
/* -------------------------------------------------------------- */
int crap_number_from_name(char *name)
{
2020-12-31 00:46:12 +01:00
int idx, retval;
2020-12-30 14:42:44 +01:00
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( '%s' )\n", __func__, name);
#endif
retval = -1; /* not found */
for (idx=0; CrapL[idx].id!=-1; idx++) {
2020-12-31 00:46:12 +01:00
if (0 == strcmp(CrapL[idx].name, name)) {
2020-12-30 14:42:44 +01:00
// fprintf(stderr, "found '%s' -> %d\n", name,
// CrapL[idx].id);
retval = CrapL[idx].id;
break;
}
}
2020-11-10 19:30:49 +01:00
2020-12-30 14:42:44 +01:00
return retval; /* not found */
2020-11-10 19:30:49 +01:00
}
2020-11-02 01:25:00 +01:00
/* -------------------------------------------------------------- */