Compare commits
5 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 28698c4f60 | |||
| c842ff3f54 | |||
| f36984db0d | |||
| 3dfaff7df4 | |||
|
bbc0309591 |
91
.gitignore
vendored
91
.gitignore
vendored
@ -1,23 +1,18 @@
|
||||
|
||||
lib/*.o
|
||||
lib/t
|
||||
lib/*.fimg
|
||||
lib/*.png
|
||||
lib/*.gif
|
||||
build
|
||||
|
||||
# src/lib/*.o
|
||||
src/lib/t
|
||||
src/lib/*.fimg
|
||||
src/lib/*.png
|
||||
src/lib/*.gif
|
||||
|
||||
*.o
|
||||
*.a
|
||||
gmon.out
|
||||
cscope.out
|
||||
|
||||
*.swp
|
||||
|
||||
*.pnm
|
||||
*.pgm
|
||||
*.fimg
|
||||
essai
|
||||
MANIFEST
|
||||
tarball
|
||||
|
||||
*/*.ps
|
||||
doc/*.toc
|
||||
@ -30,32 +25,62 @@ doc/*.ind
|
||||
doc/co*.tex
|
||||
doc/foo.html
|
||||
|
||||
src/funcs/t
|
||||
src/funcs/*.o
|
||||
src/funcs/*.png
|
||||
src/funcs/V/*
|
||||
src/src/funcs/*.gif
|
||||
src/funcs/*.fits
|
||||
src/funcs/*.tiff
|
||||
src/funcs/toto
|
||||
|
||||
scripts/*.fimg
|
||||
scripts/*.pnm
|
||||
scripts/*.gif
|
||||
|
||||
v4l2/t
|
||||
v4l2/capture
|
||||
v4l2/grabvidseq
|
||||
v4l2/*.o
|
||||
v4l2/*.ppm
|
||||
v4l2/*.png
|
||||
v4l2/*.fits
|
||||
v4l2/*.tiff
|
||||
v4l2/video-infos
|
||||
v4l2/nc-camcontrol
|
||||
src/v4l2/t
|
||||
src/v4l2/capture
|
||||
src/v4l2/grabvidseq
|
||||
src/v4l2/*.o
|
||||
src/v4l2/*.ppm
|
||||
src/v4l2/*.png
|
||||
src/v4l2/*.fits
|
||||
src/v4l2/*.tiff
|
||||
src/v4l2/video-infos
|
||||
src/v4l2/nc-camcontrol
|
||||
|
||||
# tools/fimg2png
|
||||
# tools/fimg2pnm
|
||||
# tools/fimg2tiff
|
||||
# tools/fimg2fits
|
||||
# tools/fimg2text
|
||||
# tools/fimgstats
|
||||
# tools/fimghalfsize
|
||||
# tools/mkfimg
|
||||
# tools/png2fimg
|
||||
# tools/addtga2fimg
|
||||
# tools/addpnm2fimg
|
||||
# tools/cumulfimgs
|
||||
# tools/fimgops
|
||||
# tools/fimgfx
|
||||
src/tools/*.png
|
||||
src/tools/*.tiff
|
||||
|
||||
Fonderie/*.o
|
||||
Fonderie/*.png
|
||||
Fonderie/*.pnm
|
||||
Fonderie/*.gif
|
||||
Fonderie/*.fimg
|
||||
Fonderie/fonderie
|
||||
Fonderie/interpolator
|
||||
Fonderie/t
|
||||
Fonderie/singlepass
|
||||
Fonderie/crapdef.h
|
||||
Fonderie/crapstr.h
|
||||
extras/Fonderie/*.o
|
||||
extras/Fonderie/*.png
|
||||
extras/Fonderie/*.pnm
|
||||
extras/Fonderie/*.gif
|
||||
extras/Fonderie/*.fimg
|
||||
extras/extras/Fonderie/fonderie
|
||||
extras/Fonderie/interpolator
|
||||
extras/Fonderie/t
|
||||
extras/Fonderie/singlepass
|
||||
extras/Fonderie/crapdef.h
|
||||
extras/Fonderie/crapstr.h
|
||||
|
||||
extras/experiment/assemblage
|
||||
extras/experiment/extracteur
|
||||
extras/experiment/*.fimg
|
||||
extras/experiment/*.pnm
|
||||
extras/experiment/*.o
|
||||
|
||||
|
||||
@ -1,28 +0,0 @@
|
||||
#!/usr/bin/awk -f
|
||||
|
||||
#
|
||||
# this utility script make a file who
|
||||
# is includet by 'crapulator.c'
|
||||
#
|
||||
BEGIN {
|
||||
print "// -------------------------------------"
|
||||
print "// generated file, do not edit by hand !";
|
||||
print "// -------------------------------------"
|
||||
print "Crapulor CrapL[] = {";
|
||||
}
|
||||
|
||||
# $1 is the badly brain-designed numeric id
|
||||
# $2 is the user name of the filter
|
||||
# $3 and $4 are two not used parameters
|
||||
#
|
||||
{
|
||||
name = sprintf("CR_%s", $2)
|
||||
printf " { %-14s, \"%s\", %d, %f }, // #%d\n",
|
||||
name, $2, $3, $4, $1;
|
||||
}
|
||||
|
||||
END {
|
||||
print " { -1, NULL }"
|
||||
print " };"
|
||||
print "// ! generated file, do not edit by hand !"
|
||||
}
|
||||
@ -1,53 +0,0 @@
|
||||
/*
|
||||
* utilfuncs.c
|
||||
*
|
||||
* new Sat Nov 9 22:15:15 UTC 2024
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#include "utilfuncs.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* -------------------------------------------------------------- */
|
||||
int check_if_export_dir_is_valid(char *path, int action)
|
||||
{
|
||||
int foo;
|
||||
struct stat statbuf;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( '%s', %d )\n", __func__, path, action);
|
||||
#endif
|
||||
|
||||
foo = stat(path, &statbuf);
|
||||
if (foo) {
|
||||
if (verbosity) perror(path);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, " mode 0x%x\n", statbuf.st_mode);
|
||||
#endif
|
||||
if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
|
||||
if (verbosity) fprintf(stderr, "%s: Not a directory\n", path);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* OK, c'est un repertoire, mais peut-on écrire dedans ? */
|
||||
foo = access(path, W_OK);
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, " access '%s' = %d\n", path, foo);
|
||||
#endif
|
||||
if (0 != foo) {
|
||||
if (verbosity) fprintf(stderr, "%s: can't write\n", path);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1; /* export dir is OK */
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
|
||||
@ -1,11 +0,0 @@
|
||||
/*
|
||||
* utilfuncs.c
|
||||
*
|
||||
* new Sat Nov 9 22:15:49 UTC 2024
|
||||
*/
|
||||
|
||||
/* -------------------------------------------------------------- */
|
||||
|
||||
int check_if_export_dir_is_valid(char *path, int action);
|
||||
|
||||
/* -------------------------------------------------------------- */
|
||||
@ -1,6 +0,0 @@
|
||||
|
||||
#
|
||||
# This file is the 'grandmasta' of the compilation process.
|
||||
# for now, this is juste a wip idea.
|
||||
#
|
||||
|
||||
14
LICENSE
14
LICENSE
@ -1,14 +0,0 @@
|
||||
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
|
||||
Version 2, December 2004
|
||||
|
||||
Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
|
||||
|
||||
Everyone is permitted to copy and distribute verbatim or modified
|
||||
copies of this license document, and changing it is allowed as long
|
||||
as the name is changed.
|
||||
|
||||
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. You just DO WHAT THE FUCK YOU WANT TO.
|
||||
|
||||
94
Makefile
94
Makefile
@ -1,37 +1,77 @@
|
||||
####################################################
|
||||
# Before running make, you must have #
|
||||
# a look to the 'build.sh' script ! #
|
||||
####################################################
|
||||
# CC_OPTS = -Wall -fpic -g -pg -no-pie -DDEBUG_LEVEL=0
|
||||
# LD_OPTS = libfloatimg.a -pg -lm
|
||||
|
||||
COPT = -Wall -Wextra -fpic -g -no-pie -DDEBUG_LEVEL=0
|
||||
LDOPT = libfloatimg.a -g -lm
|
||||
LIB_DIR = build/lib
|
||||
|
||||
all: essai
|
||||
OBJ_DIR = build/obj
|
||||
|
||||
#---------------------------------------------------------------
|
||||
STATIC_LIB = $(LIB_DIR)/libfloatimg-lib.a
|
||||
|
||||
essai: essai.c libfloatimg.a floatimg.h Makefile
|
||||
gcc $(COPT) $< $(LDOPT) -lpnglite -lz -o $@
|
||||
DYN_LIB = $(LIB_DIR)/libfloatimg.so
|
||||
|
||||
install:
|
||||
@echo "=== Use the 'install.sh' script ==="
|
||||
VERBOSITY = 0
|
||||
|
||||
#---------------------------------------------------------------
|
||||
all: lib funcs tools v4l2
|
||||
|
||||
TOTAR = *.[ch] Makefile *.sh *.md \
|
||||
doc/the*.tex doc/mk*.sh doc/*.txt \
|
||||
funcs/*.[ch] funcs/Makefile \
|
||||
tools/*.[ch] tools/*.sh tools/README.md tools/Makefile \
|
||||
v4l2/*.[ch] v4l2/Makefile \
|
||||
scripts/*.sh scripts/README.md \
|
||||
lib/*.[ch] lib/Makefile
|
||||
# shared: $(DYN_LIB)
|
||||
|
||||
lines: $(TOTAR)
|
||||
@wc $(TOTAR) | sort -n
|
||||
# $(DYN_LIB): lib funcs
|
||||
|
||||
tarball: $(TOTAR)
|
||||
date > tarball
|
||||
ls $(TOTAR) | sed 's/^/FloatImg\//' > MANIFEST
|
||||
( cd .. ; tar zcvf floatimg.tar.gz `cat FloatImg/MANIFEST` )
|
||||
lib:
|
||||
$(MAKE) -C src/lib all
|
||||
|
||||
funcs: lib
|
||||
$(MAKE) -C src/funcs
|
||||
# link lib & funcs for shared library
|
||||
echo "int verbosity = $(VERBOSITY);" > $(OBJ_DIR)/verbosity.c
|
||||
gcc -c $(OBJ_DIR)/verbosity.c -o $(OBJ_DIR)/verbosity.o
|
||||
gcc -shared $(OBJ_DIR)/*.o -lnetpbm -lpnglite -lcfitsio -ltiff -lz -lm -o $(DYN_LIB)
|
||||
|
||||
|
||||
tools: lib
|
||||
mkdir -p build/bin
|
||||
$(MAKE) -C src/tools
|
||||
|
||||
v4l2:
|
||||
mkdir -p build/bin
|
||||
$(MAKE) -C src/v4l2
|
||||
|
||||
clean:
|
||||
$(MAKE) -C src/lib clean
|
||||
$(MAKE) -C src/funcs clean
|
||||
$(MAKE) -C src/tools clean
|
||||
$(MAKE) -C src/v4l2 clean
|
||||
rm -rf "./build"
|
||||
|
||||
install: all
|
||||
cp src/floatimg.h /usr/local/include
|
||||
cp build/lib/* /usr/local/lib
|
||||
cp build/bin/* /usr/local/bin
|
||||
|
||||
|
||||
# all: essai
|
||||
|
||||
# #---------------------------------------------------------------
|
||||
|
||||
# essai: essai.c libfloatimg.a floatimg.h Makefile
|
||||
# gcc $(COPT) $< $(LDOPT) -lpnglite -lz -o $@
|
||||
|
||||
# #---------------------------------------------------------------
|
||||
|
||||
# TOTAR = *.[ch] Makefile *.sh *.md \
|
||||
# doc/the*.tex doc/mk*.sh doc/*.txt \
|
||||
# funcs/*.[ch] funcs/Makefile \
|
||||
# tools/*.[ch] tools/*.sh tools/README.md tools/Makefile \
|
||||
# v4l2/*.[ch] v4l2/Makefile \
|
||||
# scripts/*.sh scripts/README.md \
|
||||
# lib/*.[ch] lib/Makefile
|
||||
|
||||
# lines: $(TOTAR)
|
||||
# @wc $(TOTAR) | sort -n
|
||||
|
||||
# tarball: $(TOTAR)
|
||||
# date > tarball
|
||||
# ls $(TOTAR) | sed 's/^/FloatImg\//' > MANIFEST
|
||||
# ( cd .. ; tar zcvf floatimg.tar.gz `cat FloatImg/MANIFEST` )
|
||||
# #---------------------------------------------------------------
|
||||
|
||||
#---------------------------------------------------------------
|
||||
|
||||
76
README.md
76
README.md
@ -1,3 +1,14 @@
|
||||
# FloatImg4PythonBinding
|
||||
|
||||
Un fork de la galactique bibliothèque FloatImg de tTh, réaménagé pour permettre une utilisation depuis Python avec l'embryonnaire binding https://git.tetalab.org/Mutah/python-FloatImg/ (seulement sur la branche develop pour le moment)
|
||||
|
||||
Pas de révolution mais :
|
||||
|
||||
- production d'une bibliothèque partagée
|
||||
- arborescence remanié : les meubles ont changés de place : les sources sont dans `src`, les expérimentations dans `extra` et les binaires sont produits dans `build`
|
||||
- build system : un Makefile racine avec des cibles générales : `all` pour tout builder, `lib` pour la bibliothèque de base, `funcs`
|
||||
|
||||
|
||||
# Traitement des images en virgule flottante.
|
||||
|
||||
C'est d"abord un ensemble de fonctions pour traiter des images avec une énorme dynamique
|
||||
@ -7,6 +18,7 @@ voire même des [films flous](Fonderie/).
|
||||
|
||||
|
||||
|
||||
|
||||
Il y a une [description](http://la.buvette.org/photos/cumul/) bien plus
|
||||
pas trop longue pour les curieux, et un début de
|
||||
[documentation](http://la.buvette.org/photos/cumul/the_floatimg_hack.pdf)
|
||||
@ -14,27 +26,14 @@ pour les codeurs.
|
||||
Le service après-vente est (plus ou moins bien) assuré sur
|
||||
la [mailing list](https://lists.tetalab.org/mailman/listinfo/tetalab) et/ou
|
||||
le canal IRC #tetalab sur le réseau de
|
||||
[Libera.Chat](https://libera.chat/)...
|
||||
[Freenode](https://webchat.freenode.net/)...
|
||||
|
||||
Par ailleurs, d'autres expérimentations sont
|
||||
[en cours](http://la.buvette.org/photos/cumul/fonderie/vidz.html#interpolator)
|
||||
sur le traitement et l'assemblage de ces images floues dans le but de faire
|
||||
des films flous.
|
||||
|
||||
## *Show us the code !*
|
||||
|
||||
Il y a plusieurs répertoires contenant le code source, en voici
|
||||
la liste :
|
||||
|
||||
* [lib](lib/README.md) : le noyau du système, fonctions de base.
|
||||
* [funcs](funcs/README.md) : fonctions de support : export, traitement
|
||||
filtrage, effets...
|
||||
* [tools](tools/README.md) : utilitaires divers, outils de debug et gadgets.
|
||||
* [v4l2](v4l2/README.md): gestion des webcams sous Linux.
|
||||
* [experiment](experiment/README.md) : fonctions en chantier, qui migreront
|
||||
un jour dans d'autres catégories.
|
||||
* [contrib](contrib/README.md) : des choses peu ou pas maintenues.
|
||||
|
||||
*En avant vers l'infini, et au-delà...*
|
||||
|
||||
## Dépendances
|
||||
|
||||
@ -42,41 +41,22 @@ Bien entendu, avant tout, il faut installer quelques outils et
|
||||
dépendances. Je vais tenter de les lister dans le plus grand
|
||||
désordre (à la sauce Debian) :
|
||||
|
||||
```
|
||||
apt install libtiff-dev
|
||||
apt install libpnglite-dev
|
||||
apt install liblo-dev
|
||||
apt install libv4l2-dev
|
||||
apt install libcfitsio-dev
|
||||
apt install libnetpbm-dev
|
||||
apt install libncurses-dev
|
||||
```
|
||||
Bon, OK, je suis en train de changer de machine, et ça serait vraiment
|
||||
cool d'avoir juste une ligne à c'n'p, donc voila :
|
||||
|
||||
```
|
||||
apt install libtiff-dev libpnglite-dev liblo-dev libv4l2-dev \
|
||||
libcfitsio-dev libnetpbm-dev libncurses-dev
|
||||
```
|
||||
Il est probable que j'en oublie.
|
||||
Et ya Debian qui change des trucs, alors, ça marche plus, du
|
||||
genre que c'est la deuxième fois que ça m'arrive.
|
||||
|
||||
```
|
||||
E: Unable to locate package libv4l2-dev
|
||||
E: Unable to locate package libnetpbm-dev
|
||||
```bash
|
||||
sudo apt install libtiff-dev libpnglite-dev liblo-dev libv4l2-dev libcfitsio-dev libnetpbm-dev
|
||||
```
|
||||
|
||||
Sauce Ubuntu :
|
||||
|
||||
```bash
|
||||
sudo apt install libtiff-dev libpnglite-dev liblo-dev libv4l-dev libcfitsio-dev libnetpbm10-dev libncurses5-dev
|
||||
```
|
||||
|
||||
Ensuite, j'ai dans l'idée de construire
|
||||
um meta-packet à la sauce Debian pour installer facilement tout ce
|
||||
qui sert à faire fonctionner ce kluge. Ensuite, j'irais voir du
|
||||
coté de pkg-config.
|
||||
|
||||
Certains outils externes sont aussi utiles :
|
||||
|
||||
- gnuplot, pour analyser des données,
|
||||
- ImageMagick, parce que Brunus aime ça,
|
||||
- LaTeX, pour la (trop maigre) documentation.
|
||||
- gnuplot
|
||||
- ImageMagick
|
||||
- LaTeX
|
||||
|
||||
## Documentation
|
||||
|
||||
@ -84,10 +64,4 @@ Encore trop légère, mais déja [présente](doc/).
|
||||
C'est à vous de compiler le
|
||||
[PDF](http://la.buvette.org/photos/cumul/the_floatimg_hack.pdf)
|
||||
|
||||
## TODO
|
||||
|
||||
https://berthub.eu/articles/posts/always-do-this-floating-point/
|
||||
|
||||
## Conclusion
|
||||
|
||||
*Your mileage may vary...*
|
||||
|
||||
41
build.sh
41
build.sh
@ -1,41 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
set -e ; set -u
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
function build
|
||||
{
|
||||
echo "============= $1 =============="
|
||||
curdir=${PWD}
|
||||
cd $1
|
||||
make
|
||||
error=$?
|
||||
cd ${curdir}
|
||||
|
||||
if [ ${error} -ne 0 ]
|
||||
then
|
||||
echo "=== error on $1 = ${error}"
|
||||
exit 1
|
||||
fi
|
||||
}
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
build lib
|
||||
build funcs
|
||||
build tools
|
||||
build v4l2
|
||||
build Fonderie
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
echo "========== Project root ==============="
|
||||
make
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
14
contrib/.gitignore
vendored
14
contrib/.gitignore
vendored
@ -1,14 +0,0 @@
|
||||
|
||||
fimg2povhf
|
||||
demo_fmorph
|
||||
|
||||
toto
|
||||
core
|
||||
|
||||
*.tga
|
||||
*.png
|
||||
*.pnm
|
||||
*.gif
|
||||
*.fimg
|
||||
*.mp4
|
||||
|
||||
@ -1,18 +0,0 @@
|
||||
|
||||
DBGL = -DDEBUG_LEVEL=1 -g
|
||||
|
||||
fimg2povhf: fimg2povhf.c Makefile
|
||||
gcc -Wall $(DBGL) $< -limage -lfloatimg -lm -o $@
|
||||
|
||||
# --------------------------------------------------------
|
||||
|
||||
demo_fmorph: demo_fmorph.c Makefile
|
||||
gcc -Wall $(DBGL) $< -lfloatimg -lpnglite -lm -o $@
|
||||
|
||||
in.fimg: Makefile
|
||||
mkfimg -t tpat0 -v $@ 640 480
|
||||
|
||||
out.png: in.fimg demo_fmorph
|
||||
./demo_fmorph $< $@
|
||||
|
||||
# --------------------------------------------------------
|
||||
@ -1,14 +0,0 @@
|
||||
# Contributions
|
||||
|
||||
## fimg2povhf
|
||||
|
||||
Need some external garbage, sorry.
|
||||
|
||||
## do_eff_spass.sh
|
||||
|
||||
Script shell permettant (en théorie) de faire un montage
|
||||
d'une petite séquence de chacun des effets disponibles
|
||||
dans la Fonderie. `singlepass` inside.
|
||||
|
||||
|
||||
|
||||
@ -1,116 +0,0 @@
|
||||
/*
|
||||
* DEMONSTRATOR FOR FMORPHO
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <floatimg.h>
|
||||
|
||||
int verbosity = 1;
|
||||
|
||||
#define DF_W 512
|
||||
#define DF_H 128
|
||||
|
||||
/* ~~~ -------------------------------------------------------------- +++ */
|
||||
int demo_fmorph(char *srcf, char *dsti, int mode)
|
||||
{
|
||||
FloatImg simg, // image source
|
||||
timg, uimg, // intermediaires
|
||||
dimg; // destination
|
||||
FimgArea51 rect;
|
||||
char line[200];
|
||||
|
||||
int foo, pass, hpos;
|
||||
|
||||
fprintf(stderr, ">>> %s ( '%s' '%s' %d )\n", __func__, srcf, dsti, mode);
|
||||
|
||||
/*
|
||||
* chargement image source
|
||||
*/
|
||||
foo = fimg_create_from_dump(srcf, &simg);
|
||||
fprintf(stderr, " load of %s --> %d\n", srcf, foo);
|
||||
if (foo) {
|
||||
return foo;
|
||||
}
|
||||
|
||||
/*
|
||||
* images temporaires
|
||||
*/
|
||||
foo = fimg_create(&timg, DF_W, DF_H, FIMG_TYPE_RGB);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d create T img\n", foo);
|
||||
return foo;
|
||||
}
|
||||
foo = fimg_create(&uimg, DF_W, DF_H, FIMG_TYPE_RGB);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d create U img\n", foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
/*
|
||||
* image de destination
|
||||
*/
|
||||
foo = fimg_create(&dimg, DF_W, DF_H*9, FIMG_TYPE_RGB);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d create D img\n", foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
/*
|
||||
* this is an iterator
|
||||
*/
|
||||
rect.x = 20; rect.y = 20;
|
||||
rect.w = DF_W; rect.h = DF_H;
|
||||
|
||||
for (pass=0; pass<9; pass++) {
|
||||
hpos = pass * DF_H;
|
||||
fprintf(stderr, "pass %d, hpos %d\n", pass, hpos);
|
||||
foo = fimg_extractor(&simg, &timg, &rect);
|
||||
|
||||
// sprintf(line, "S_%02d.png", pass);
|
||||
// foo = fimg_save_as_png(&timg, line, 0);
|
||||
|
||||
foo = fimg_filtre_morpho_0(&timg, &uimg, pass);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d filtre morpho, pass %d\n",
|
||||
foo, pass);
|
||||
exit(1);
|
||||
}
|
||||
sprintf(line, "D_%02d.png", pass);
|
||||
foo = fimg_save_as_png(&uimg, line, 0);
|
||||
|
||||
foo = fimg_incrustator_0(&uimg, &dimg, 0, hpos, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d incrustator\n", foo);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
foo = fimg_save_as_png(&dimg, dsti, 0);
|
||||
/*
|
||||
* do some cleanup
|
||||
*/
|
||||
fimg_destroy(&simg); fimg_destroy(&timg); fimg_destroy(&dimg);
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ~~~ -------------------------------------------------------------- +++ */
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int foo;
|
||||
|
||||
fimg_print_version(1);
|
||||
|
||||
if (3 != argc) {
|
||||
fprintf(stderr, "usage:\n\t%s src.fimg dst.png\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
foo = demo_fmorph(argv[1], argv[2], 0);
|
||||
fprintf(stderr, " got --> %d\n", foo);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ~~~ -------------------------------------------------------------- +++ */
|
||||
@ -1,163 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
set -e
|
||||
|
||||
SPASS="../Fonderie/singlepass"
|
||||
|
||||
SRCDIR=$HOME"/Essais/PS-eye/frames/"
|
||||
DSTPOL=$HOME"/TMP/"
|
||||
echo "source = " $SRCDIR
|
||||
echo "spool = " $DSTPOL
|
||||
|
||||
LINKFARM=$DSTPOL"LinkFarm"
|
||||
echo "linkfarm = " $LINKFARM
|
||||
|
||||
# VIDZ="$HOME/BU/vrac/all_effects.mp4"
|
||||
VIDZ="foo.mp4"
|
||||
echo "lolvidz = " $VIDZ
|
||||
|
||||
LINKNUM=0
|
||||
|
||||
# --------------------------------------------
|
||||
|
||||
do_an_effect_pass()
|
||||
{
|
||||
local effect=$1
|
||||
local ddir=$2
|
||||
|
||||
figlet "$effect" ; echo
|
||||
echo " files to ===> " $ddir
|
||||
|
||||
rm -f $ddir/?????.png
|
||||
|
||||
$SPASS -F $effect \
|
||||
-g $SRCDIR/'?????.fimg' \
|
||||
-O $ddir \
|
||||
-r 1
|
||||
|
||||
}
|
||||
|
||||
# --------------------------------------------
|
||||
insert_blank()
|
||||
{
|
||||
local count=$1
|
||||
|
||||
local imgname="$DSTPOL/blank.fimg"
|
||||
|
||||
if [ ! -r $imgname ] ; then
|
||||
mkfimg -v -t black $imgname 640 480
|
||||
fimg2png -v $imgname $DSTPOL/blank.png
|
||||
echo "blankimage done" | boxes
|
||||
# display $DSTPOL/blank.png &
|
||||
# exit
|
||||
fi
|
||||
|
||||
for foo in $(seq 0 $count)
|
||||
do
|
||||
linkname=$(printf "%s/L%05d.png" $LINKFARM $LINKNUM)
|
||||
ln --force --symbolic $DSTPOL/blank.png $linkname
|
||||
# file $linkname
|
||||
LINKNUM=$(( LINKNUM + 1 ))
|
||||
done
|
||||
}
|
||||
# --------------------------------------------
|
||||
|
||||
make_the_linkfarm_from()
|
||||
{
|
||||
local effname=$1
|
||||
local sdir=$2
|
||||
|
||||
echo "====== Linkfarming from " $sdir \
|
||||
"====== avec" $(ls $sdir | wc -l) "images"
|
||||
|
||||
mogrify \
|
||||
-font Utopia-Bold \
|
||||
-pointsize 64 \
|
||||
-kerning 9 \
|
||||
-fill Gray90 \
|
||||
-stroke Gray10 \
|
||||
-strokewidth 2 \
|
||||
-gravity South-East \
|
||||
-annotate +30+20 $effname \
|
||||
$sdir/*.png
|
||||
|
||||
for img in $(ls -1 $sdir/?????.png)
|
||||
do
|
||||
|
||||
linkname=$(printf "%s/L%05d.png" $LINKFARM $LINKNUM)
|
||||
# echo "image = " $img
|
||||
# echo "link = " $linkname
|
||||
|
||||
ln --force --symbolic $img $linkname
|
||||
|
||||
LINKNUM=$(( LINKNUM + 1 ))
|
||||
done
|
||||
echo " linkfarming done"
|
||||
}
|
||||
# --------------------------------------------
|
||||
# traite tous les effets
|
||||
|
||||
do_all_the_effects()
|
||||
{
|
||||
EFFECTS=$( $SPASS -L | sort )
|
||||
|
||||
banner 'FULL RUN'
|
||||
|
||||
for effect in $EFFECTS
|
||||
do
|
||||
DDIR=$DSTPOL"/$effect"
|
||||
|
||||
if [ -d $DDIR ] ; then
|
||||
rm -f $DDIR"/?????.png"
|
||||
fi
|
||||
if [ ! -r $DDIR ] ; then
|
||||
mkdir -v $DDIR
|
||||
fi
|
||||
|
||||
do_an_effect_pass $effect $DDIR
|
||||
make_the_linkfarm_from $effect $DDIR
|
||||
|
||||
insert_blank 30
|
||||
done
|
||||
}
|
||||
|
||||
# --------------------------------------------
|
||||
|
||||
debug_run()
|
||||
{
|
||||
local eff=$1
|
||||
local DDIR=$DSTPOL"/$eff"
|
||||
|
||||
banner 'DEBUG RUN'
|
||||
echo "DDIR = " $DDIR
|
||||
|
||||
do_an_effect_pass $eff $DDIR
|
||||
make_the_linkfarm_from $eff $DDIR
|
||||
}
|
||||
|
||||
# --------------------------------------------
|
||||
# MAIN
|
||||
|
||||
echo
|
||||
|
||||
rm -v -f $LINKFARM/L*.png ; echo
|
||||
|
||||
insert_blank 30
|
||||
|
||||
# debug_run 'rndblks'
|
||||
do_all_the_effects
|
||||
|
||||
banner 'encoding'
|
||||
|
||||
ffmpeg -nostdin \
|
||||
-loglevel warning \
|
||||
-y -r 30 -f image2 -i ${LINKFARM}/L%05d.png \
|
||||
-metadata artist='---[ tTh ]---' \
|
||||
-metadata title='---[ All the 'Fonderie' effects ]---' \
|
||||
-preset veryslow \
|
||||
-c:v libx264 -pix_fmt yuv420p \
|
||||
$VIDZ
|
||||
|
||||
echo " encoding of " $VIDZ " . . . . . [done]"
|
||||
|
||||
|
||||
@ -1,116 +0,0 @@
|
||||
/*
|
||||
* convertir une image flottante en champ d'altitude
|
||||
*
|
||||
* nouveau 64 ernest renan - 20220108
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "tthimage.h"
|
||||
#include "floatimg.h"
|
||||
|
||||
int verbosity;
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
int This_is_the_real_conversion(FloatImg *fimg, Image_Desc *hf, int k)
|
||||
{
|
||||
int foo;
|
||||
float minmax[6];
|
||||
int x, y, h;
|
||||
float rgb[6], cumul;
|
||||
float maxi;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, fimg, hf, k);
|
||||
#endif
|
||||
|
||||
foo = fimg_get_minmax_rgb(fimg, minmax);
|
||||
// fimg_print_minmax(minmax, "source");
|
||||
|
||||
maxi = 0.0;
|
||||
|
||||
for (y=0; y<fimg->height; y++) {
|
||||
for (x=0; x<fimg->width; x++) {
|
||||
foo = fimg_get_rgb(fimg, x, y, rgb);
|
||||
/* non-magic nuabmer spotted */
|
||||
cumul = 1.732 * (rgb[1] + rgb[3] + rgb[5]);
|
||||
if (cumul > maxi) maxi = cumul;
|
||||
h = (int)cumul;
|
||||
foo = Image_hf15_plot(hf, x, y, h);
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(stderr, "--- the critical maximum is %f\n", maxi);
|
||||
|
||||
return FULL_NUCKED;
|
||||
}
|
||||
/* ------------------------------------------------------------------ */
|
||||
int Convertir_Fimg_to_Povhf(char *fimgname, char *hfname, int k)
|
||||
{
|
||||
FloatImg fimg;
|
||||
Image_Desc *hf;
|
||||
int wid, hei;
|
||||
int foo;
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %s %s %d )\n", __func__, fimgname, hfname, k);
|
||||
#endif
|
||||
|
||||
foo = fimg_create_from_dump(fimgname, &fimg);
|
||||
fprintf(stderr, "load of %s --> %d\n", fimgname, foo);
|
||||
if (foo) {
|
||||
return foo;
|
||||
}
|
||||
|
||||
wid = fimg.width; hei = fimg.height; // nice alias
|
||||
fprintf(stderr, " source picture size %dx%d\n", wid, hei);
|
||||
|
||||
hf = Image_alloc(wid, hei, IMAGE_RGB);
|
||||
fprintf(stderr, "hf alloc -> %p\n", hf);
|
||||
if (NULL == hf) {
|
||||
return NULL_POINTER;
|
||||
}
|
||||
|
||||
foo = This_is_the_real_conversion(&fimg, hf, k);
|
||||
fprintf(stderr, "real conversion -> %d\n", foo);
|
||||
|
||||
foo = Image_TGA_save(hfname, hf, 0);
|
||||
fprintf(stderr, "export as tga -> %d\n", foo);
|
||||
|
||||
return FULL_NUCKED;
|
||||
}
|
||||
/* ------------------------------------------------------------------ */
|
||||
void help(int nu)
|
||||
{
|
||||
printf("usage :\n");
|
||||
printf("\t$ fimg2povhf src.fimg dst.tga\n");
|
||||
}
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int foo;
|
||||
|
||||
verbosity = 1;
|
||||
|
||||
// printf("%s: argc = %d\n", argv[0], argc);
|
||||
|
||||
if (3 != argc) {
|
||||
help(0);
|
||||
exit(0);
|
||||
}
|
||||
|
||||
if (verbosity > 1) {
|
||||
Image_print_version(3);
|
||||
fimg_print_version(3);
|
||||
}
|
||||
|
||||
foo = Convertir_Fimg_to_Povhf(argv[1], argv[2], 0);
|
||||
fprintf(stderr, "retour conversion was %d\n", foo);
|
||||
|
||||
fprintf(stderr, "end\n\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
@ -1,31 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
src="/dev/shm/foo.fimg"
|
||||
dst="hf.tga"
|
||||
TMPDIR=${HOME}/TMP
|
||||
|
||||
POVOPT="-w512 -h342 +q9 -a "
|
||||
|
||||
rm $TMPDIR/hf???.png
|
||||
|
||||
for idx in $(seq 0 60)
|
||||
do
|
||||
|
||||
echo "========================== " $idx
|
||||
|
||||
grabvidseq -v \
|
||||
-d /dev/video0 -s 640x480 \
|
||||
-n 60 -p 1.0 \
|
||||
-o ${src}
|
||||
|
||||
./fimg2povhf $src $dst
|
||||
|
||||
out=$(printf "%s/hf%03d.png" $TMPDIR $idx)
|
||||
echo "raytracing " ${POVOPT} $out
|
||||
povray -iscene.pov ${POVOPT} -o${out} 2> pov.stderr
|
||||
# tail -15 pov.stderr
|
||||
|
||||
done
|
||||
|
||||
convert -delay 10 -colors 240 $TMPDIR/hf???.png foo.gif
|
||||
|
||||
@ -1,41 +0,0 @@
|
||||
|
||||
/* scene demo conversion floatimg -> height field */
|
||||
|
||||
#version 3.7;
|
||||
|
||||
global_settings {
|
||||
ambient_light rgb <0.07, 0.07, 0.07>
|
||||
assumed_gamma 1.0
|
||||
}
|
||||
|
||||
#include "colors.inc"
|
||||
|
||||
height_field {
|
||||
tga "hf.tga"
|
||||
smooth
|
||||
pigment { color Orange*0.7 }
|
||||
translate <-0.5, 0, -0.5>
|
||||
// scale 2
|
||||
translate y*0.002
|
||||
}
|
||||
|
||||
camera {
|
||||
location <-0.86, 4, -6.20>
|
||||
look_at <0, 0, 0>
|
||||
angle 14
|
||||
}
|
||||
|
||||
plane {
|
||||
<0, 1, 0>, 0
|
||||
pigment {
|
||||
hexagon
|
||||
pigment { color Gray20 },
|
||||
pigment { color Gray10 },
|
||||
pigment { color Gray30 }
|
||||
}
|
||||
scale 0.27
|
||||
}
|
||||
|
||||
|
||||
light_source { <-9, 2, 3> color White }
|
||||
|
||||
@ -1,14 +1,7 @@
|
||||
#!/bin/bash
|
||||
|
||||
#
|
||||
# this script generate some picz for the PDF documentation
|
||||
# and was called by mkdoc.sh
|
||||
#
|
||||
|
||||
PI=" 3.141592654 "
|
||||
|
||||
# ---------------------------------------------------
|
||||
|
||||
OUT="cos01.tex"
|
||||
|
||||
gnuplot << __EOF__
|
||||
@ -31,8 +24,6 @@ __EOF__
|
||||
|
||||
wc $OUT
|
||||
|
||||
# ---------------------------------------------------
|
||||
|
||||
OUT="cos010.tex"
|
||||
|
||||
gnuplot << __EOF__
|
||||
@ -54,5 +45,3 @@ plot \
|
||||
__EOF__
|
||||
|
||||
wc $OUT
|
||||
|
||||
# ---------------------------------------------------
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
14
experiment/.gitignore
vendored
14
experiment/.gitignore
vendored
@ -1,14 +0,0 @@
|
||||
|
||||
|
||||
*.fimg
|
||||
*.o
|
||||
*.pnm
|
||||
*.data
|
||||
|
||||
assemblage
|
||||
extracteur
|
||||
fimg2obj
|
||||
mnt
|
||||
movepixels
|
||||
muxplanes
|
||||
tcache
|
||||
@ -1,40 +0,0 @@
|
||||
|
||||
#
|
||||
# some ugly experiments, do not use in production
|
||||
#
|
||||
|
||||
COPT = -Wall -Wextra -fpic -g -DDEBUG_LEVEL=0 -lm
|
||||
DEPS = ../floatimg.h ../libfloatimg.a Makefile
|
||||
LIBS = ../libfloatimg.a -ltiff -lpnglite -lcfitsio -lm
|
||||
|
||||
all: assemblage muxplanes movepixels mnt
|
||||
|
||||
# ---------------------------------------------------------
|
||||
|
||||
assemblage: assemblage.c ${DEPS}
|
||||
gcc $(COPT) $< ../libfloatimg.a ${LIBS} -o $@
|
||||
|
||||
muxplanes: muxplanes.c ${DEPS}
|
||||
gcc $(COPT) $< ${LIBS} -o $@
|
||||
|
||||
movepixels: movepixels.c ${DEPS}
|
||||
gcc $(COPT) $< ../libfloatimg.a ${LIBS} -o $@
|
||||
|
||||
mnt: mnt.c ${DEPS}
|
||||
gcc $(COPT) $< ../libfloatimg.a ${LIBS} -o $@
|
||||
|
||||
fimg2obj: fimg2obj.c $(DEPS)
|
||||
gcc $(COPT) $< ../libfloatimg.a ${LIBS} -o $@
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# CACHE ENGINE (wip)
|
||||
|
||||
cachengn.o: cachengn.c cachengn.h Makefile
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
tcache.o: tcache.c cachengn.h Makefile
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
tcache: tcache.o cachengn.o Makefile
|
||||
gcc $(COPT) tcache.o cachengn.o $(LIBS) -o $@
|
||||
|
||||
@ -1,29 +0,0 @@
|
||||
# Expérimentations ÀLC
|
||||
|
||||
Attention, tout ce qui se trouve dans ce répertoire ne sont que des
|
||||
essais. Certains aboutissent, et sont migrés vers `lib/`, `funcs/` ou
|
||||
`tools/`, d'autre échouent et restent trainer dans le coin en attente
|
||||
du retour de l'inspiration.
|
||||
|
||||
Le contenu de ce répertoire doit donc être considéré comme
|
||||
**volatile**. Si vous y trouvez votre bonheur, il serait sage
|
||||
d'en faire une copie personnelle...
|
||||
|
||||
## MNT
|
||||
|
||||
Modèles numériques de terrain. Rien ne marche. Plein de maths.
|
||||
Un [code](mnt.c) complexe.
|
||||
|
||||
## fimg2obj
|
||||
|
||||
Création d'un fichier .OBJ (de Wavefront) à partir d'une image
|
||||
flottante afin d'avoir des vues en 3d pertinentes, bien qu'assez
|
||||
futiles.
|
||||
|
||||
## système de cache
|
||||
|
||||
`new: Mon Jul 17 12:49:20 UTC 2023`
|
||||
|
||||
En cours : définition d'à peu-près tout ce qu'il reste à faire
|
||||
pour avoir quelque chose qui fonctionne.
|
||||
Plus d'information dans le [.h](cachengn.h).
|
||||
@ -1,145 +0,0 @@
|
||||
/*
|
||||
* the chache engine - code
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/time.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
#include "cachengn.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
static int nombre_slots = -1;
|
||||
static int index_slot = -1;
|
||||
static FimgCacheEntry *le_cache = NULL;
|
||||
|
||||
/* ------------------------------------------------------------ */
|
||||
|
||||
void cachengn_print_version(int k)
|
||||
{
|
||||
|
||||
printf("\t!!! this is the version ZERO !!!\n");
|
||||
|
||||
fprintf(stderr, "sizeof cache entry: %ld\n", sizeof(FimgCacheEntry));
|
||||
|
||||
if (k) fimg_print_version(0);
|
||||
}
|
||||
/* ------------------------------------------------------------ */
|
||||
/*
|
||||
*
|
||||
*/
|
||||
int init_empty_cache(int iw, int ih, int szc, int wtfparam)
|
||||
{
|
||||
int idx;
|
||||
|
||||
fprintf(stderr, ">>> %s ( %d %d %d %d )\n", __func__,
|
||||
iw, ih, szc, wtfparam);
|
||||
|
||||
/* MOLLYGUARD : don't init TWICE, please */
|
||||
if (NULL != le_cache) {
|
||||
fprintf(stderr, "%s: there is a cache at %p\n", __func__,
|
||||
le_cache);
|
||||
return -2;
|
||||
}
|
||||
|
||||
/* allocate an prepare memory */
|
||||
if ( NULL==(le_cache=calloc(szc, sizeof(FimgCacheEntry))) ) {
|
||||
fprintf(stderr, "%s: no memory, sorry...\n", __func__);
|
||||
return -3;
|
||||
}
|
||||
fprintf(stderr, " slot array at %p\n", le_cache);
|
||||
for (idx=0; idx<szc; idx++) {
|
||||
le_cache[idx].flags = 0xF0;
|
||||
le_cache[idx].index = idx;
|
||||
}
|
||||
|
||||
/* update private cache metadata */
|
||||
nombre_slots = szc;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------ */
|
||||
/*
|
||||
*
|
||||
*/
|
||||
FloatImg *give_me_thiz_picz(char *fname, int notused)
|
||||
{
|
||||
int idx, foo, freeslot;
|
||||
FloatImg img;
|
||||
char *nptr;
|
||||
|
||||
fprintf(stderr, ">>> %s ( '%s' %d )\n", __func__, fname, notused);
|
||||
|
||||
/* please add molly guard ! */
|
||||
|
||||
if (notused)
|
||||
fprintf(stderr, "in %s, notused was %d\n", __func__, notused);
|
||||
|
||||
/* is the floatimg already in the cahce ? */
|
||||
for (idx=0; idx<nombre_slots; idx++) {
|
||||
nptr = le_cache[idx].filename;
|
||||
if (NULL!=nptr && (! strcmp(fname, nptr))) {
|
||||
fprintf(stderr, "found '%s' at %d\n", nptr, idx);
|
||||
return le_cache[idx].image;
|
||||
}
|
||||
}
|
||||
|
||||
/* we not have this picture in our cache, so we need a free
|
||||
slot for it */
|
||||
freeslot = -1;
|
||||
for (idx=0; idx<nombre_slots; idx++) {
|
||||
if (NULL==le_cache[idx].image) {
|
||||
freeslot = idx;
|
||||
break;
|
||||
}
|
||||
}
|
||||
fprintf(stderr, "freeslot = %d\n", freeslot);
|
||||
|
||||
/* check if we can read this file */
|
||||
foo = access(fname, R_OK); /* XXX */
|
||||
if (foo) {
|
||||
perror("give_me_thiz_picz");
|
||||
return NULL;
|
||||
}
|
||||
fprintf(stderr, "file '%s' is readble\n", fname);
|
||||
|
||||
/* try to load the requested file */
|
||||
foo = fimg_create_from_dump(fname, &img);
|
||||
if (foo) {
|
||||
fprintf(stderr, "oups on %s\n", fname);
|
||||
return NULL;
|
||||
}
|
||||
/* OK, we have all the pixels in core memory */
|
||||
|
||||
return NULL;
|
||||
}
|
||||
/* ------------------------------------------------------------ */
|
||||
/*
|
||||
*
|
||||
*/
|
||||
int liste_le_cache(unsigned int flags)
|
||||
{
|
||||
int idx;
|
||||
|
||||
fprintf(stderr, ">>> %s ( Ox%X )\n", __func__, flags);
|
||||
|
||||
/* please add molly guard here */
|
||||
|
||||
fprintf(stderr, "cache at %p : %d slots, idx = %d\n",
|
||||
le_cache, nombre_slots, index_slot);
|
||||
|
||||
for (idx=0; idx<nombre_slots; idx++) {
|
||||
fprintf(stderr, "%5d ", idx);
|
||||
fprintf(stderr, "0x%02x ", le_cache[idx].flags);
|
||||
fprintf(stderr, "%p ", le_cache[idx].image);
|
||||
fprintf(stderr, "%s\n", le_cache[idx].filename);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ------------------------------------------------------------ */
|
||||
@ -1,29 +0,0 @@
|
||||
/*
|
||||
* the chache engine - header
|
||||
*/
|
||||
|
||||
void cachengn_print_version(int k);
|
||||
|
||||
typedef struct {
|
||||
int flags;
|
||||
char *filename;
|
||||
FloatImg *image;
|
||||
int index;
|
||||
} FimgCacheEntry;
|
||||
|
||||
|
||||
/*
|
||||
* parameters:
|
||||
* - iw, ik : image size
|
||||
* - szc : number of slots
|
||||
* - nbre : WTF isthat?
|
||||
*/
|
||||
int init_empty_cache(int iw, int ih, int szc, int nbre);
|
||||
|
||||
|
||||
/* /!\ the floatimg returned must be view as readonly */
|
||||
FloatImg *give_me_thiz_picz(char *fname, int notused);
|
||||
|
||||
|
||||
/* utilities functions */
|
||||
int liste_le_cache(unsigned int flags);
|
||||
@ -1,67 +0,0 @@
|
||||
|
||||
/*
|
||||
* another ugly experiment
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
int verbosity;
|
||||
|
||||
/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
|
||||
|
||||
int convert_fimg_to_obj(char *fimgfname, char *objfname, int mode)
|
||||
{
|
||||
FloatImg src;
|
||||
int foo, x, y;
|
||||
FILE *fp;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( '%s' '%s' %d )\n", __func__,
|
||||
fimgfname, objfname, mode);
|
||||
#endif
|
||||
|
||||
if (mode) {
|
||||
fprintf(stderr, "in %s(), mode must be 0, was %d\n", __func__, mode);
|
||||
}
|
||||
|
||||
foo = fimg_create_from_dump(fimgfname, &src);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d loading %f\n", foo, fimgfname);
|
||||
return foo;
|
||||
}
|
||||
|
||||
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int foo, opt;
|
||||
char *infile = "foo.fimg";
|
||||
|
||||
fprintf(stderr, "*** fimg2obj (%s %s)\n", __DATE__, __TIME__);
|
||||
|
||||
verbosity = 0;
|
||||
|
||||
#if 0
|
||||
for (foo=0; foo<argc; foo++) {
|
||||
fprintf(stderr, "%9d %s\n", foo, argv[foo]);
|
||||
}
|
||||
#endif
|
||||
|
||||
foo = convert_fimg_to_obj(infile, "foo.obj", 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "convertor give us %d\n", foo);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
|
||||
239
experiment/mnt.c
239
experiment/mnt.c
@ -1,239 +0,0 @@
|
||||
/*
|
||||
* Modeles Numeriques de Terrain -- UGLY CODE INSIDE !!
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
int verbosity;
|
||||
|
||||
/* ------------------------------------------------------------------- */
|
||||
/* for debug purpose */
|
||||
int printf_histo_gray(char *fname, int histo[], int nbre)
|
||||
{
|
||||
FILE *fp;
|
||||
int idx;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( '%s' %p %d )\n", __func__,
|
||||
fname, histo, nbre);
|
||||
#endif
|
||||
|
||||
if (NULL == (fp = fopen(fname, "w"))) {
|
||||
perror(fname);
|
||||
exit(1);
|
||||
}
|
||||
for (idx=0; idx<nbre; idx++) {
|
||||
fprintf(fp, "%6d %8d\n", idx, histo[idx]);
|
||||
}
|
||||
fclose(fp);
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* ------------------------------------------------------------------- */
|
||||
/* for debug purpose */
|
||||
int calcul_histo_gray(FloatImg *img, char *fname, int nbslots, float *pmax)
|
||||
{
|
||||
int offset, nbpix, ival;
|
||||
float pixel, minp, maxp;
|
||||
int *counts;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p '%s' %d )\n", __func__,
|
||||
img, fname, nbslots);
|
||||
#endif
|
||||
|
||||
if (FIMG_TYPE_GRAY != img->type) {
|
||||
fprintf(stderr, "%s: image is not in greylevel\n", __func__);
|
||||
return -2;
|
||||
}
|
||||
|
||||
/* allocate memory for histogram computation */
|
||||
counts = calloc(nbslots, sizeof(int));
|
||||
if (NULL == counts) {
|
||||
fprintf(stderr, "malloc fail in %s\n", __func__);
|
||||
abort();
|
||||
}
|
||||
|
||||
nbpix = img->width * img->height;
|
||||
minp = 1e30, maxp = -1e30;
|
||||
|
||||
for (offset=0; offset<nbpix; offset++) {
|
||||
pixel = img->R[offset];
|
||||
if (pixel < minp) minp = pixel;
|
||||
if (pixel > maxp) maxp = pixel;
|
||||
}
|
||||
// fprintf(stderr, " values = %g < %g\n", minp, maxp);
|
||||
|
||||
*pmax = maxp; /* copy value for the caller */
|
||||
|
||||
/* calcul de l'histogramme avec scaling */
|
||||
for (offset=0; offset<nbpix; offset++) {
|
||||
pixel = img->R[offset];
|
||||
ival = (int)((pixel * (float)nbslots) / maxp);
|
||||
counts[ival]++;
|
||||
// fprintf(stderr, "%6d %10.6f %i\n", offset, pixel, ival);
|
||||
}
|
||||
|
||||
if (NULL != fname)
|
||||
{
|
||||
printf_histo_gray(fname, counts, nbslots);
|
||||
}
|
||||
|
||||
/* garbage collect stuff */
|
||||
free(counts);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ------------------------------------------------------------------- */
|
||||
/*
|
||||
* Second try - ahem?
|
||||
*/
|
||||
int brotche_mnt_style(FloatImg *src, FloatImg *dst)
|
||||
{
|
||||
FloatImg tmp;
|
||||
int x, y, foo;
|
||||
int offset;
|
||||
float z1, z2, z3, z4;
|
||||
float a, b, c;
|
||||
float pente, minp, maxp, seuil;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p )\n", __func__, src, dst);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* trying some preprocessor filters
|
||||
*/
|
||||
foo = fimg_lissage_3x3(src);
|
||||
if (foo) fprintf(stderr, " lissage 1 -> %d\n", foo);
|
||||
foo = fimg_lissage_3x3(src);
|
||||
if (foo) fprintf(stderr, " lissage 2 -> %d\n", foo);
|
||||
|
||||
foo = fimg_killborders(src);
|
||||
if (foo) fprintf(stderr, " killborder -> %d\n", foo);
|
||||
|
||||
#define W (src->width)
|
||||
#define DX 1.0
|
||||
#define DY 1.0
|
||||
|
||||
/* allocate a graylevel image for storing la 'pente' */
|
||||
memset(&tmp, 0, sizeof(FloatImg));
|
||||
foo = fimg_create(&tmp, src->width, src->height, FIMG_TYPE_GRAY);
|
||||
if (foo) {
|
||||
fprintf(stderr, "create tmp pic --> %d\n", foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
/* calcul de la pente : a vérifier ! */
|
||||
for (y=0; y<(src->height-1); y++) {
|
||||
for (x=0; x<(src->width-1); x++) {
|
||||
offset = (y * W) + x;
|
||||
z1 = src->R[offset];
|
||||
z2 = src->R[offset+1];
|
||||
z3 = src->R[offset+W];
|
||||
z4 = src->R[offset+W+1];
|
||||
a = ( z1 + z2 + z3 + z4) / 4.0;
|
||||
b = (-z1 + z2 - z3 + z4) / 2.0 / DX;
|
||||
c = (-z1 - z2 + z3 + z4) / 2.0 / DY;
|
||||
pente = atanf(sqrt(b*b + c*c));
|
||||
tmp.R[offset] = pente;
|
||||
}
|
||||
}
|
||||
|
||||
foo = calcul_histo_gray(&tmp, "histogramme.data", 499, &maxp);
|
||||
if (foo) fprintf(stderr, "<<< calcul histo -> %d\n", foo);
|
||||
|
||||
minp = 1e10;
|
||||
seuil = 0.700 * maxp;
|
||||
fprintf(stderr, " seuil = %f\n", seuil);
|
||||
|
||||
/* ésotérisme, quand tu nous tiens... */
|
||||
for (offset=0; offset<(src->width*src->height); offset++) {
|
||||
pente = tmp.R[offset];
|
||||
if (pente > seuil) {
|
||||
if (pente < minp) minp = pente;
|
||||
}
|
||||
if (pente > maxp) maxp = pente;
|
||||
}
|
||||
// fprintf(stderr, " minp = %f maxp = %f\n", minp, maxp);
|
||||
|
||||
/* recopie dans l'image destination avec translation hauteur */
|
||||
fimg_clear(dst);
|
||||
for (offset=0; offset<(src->width*src->height); offset++) {
|
||||
pente = tmp.R[offset] - minp;
|
||||
if (pente < 0.0) {
|
||||
dst->R[offset] = -pente;
|
||||
dst->G[offset] = -pente;
|
||||
}
|
||||
else {
|
||||
dst->B[offset] = pente;
|
||||
dst->G[offset] = pente;
|
||||
}
|
||||
}
|
||||
|
||||
foo = fimg_killborders(dst);
|
||||
if (foo) fprintf(stderr, " killborder -> %d\n", foo);
|
||||
|
||||
/* clean the memory */
|
||||
fimg_destroy(&tmp);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ------------------------------------------------------------------- */
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
FloatImg src, dst;
|
||||
char *infile, *outfile;
|
||||
int foo;
|
||||
|
||||
verbosity = 1; /* FIXME */
|
||||
|
||||
if (3 != argc) {
|
||||
fprintf(stderr, "'%s' need 2 args : infile & outfile\n", argv[0]);
|
||||
fimg_print_version(0);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
infile = argv[1]; outfile = argv[2];
|
||||
|
||||
if (verbosity) fprintf(stderr,"*** MNT %s -> %s\n", infile, outfile);
|
||||
|
||||
foo = fimg_create_from_dump(infile, &src);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d loading image '%s'\n", foo, infile);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
foo = fimg_clone(&src, &dst, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d cloning image\n", foo);
|
||||
exit(1);
|
||||
}
|
||||
fimg_clear(&dst);
|
||||
|
||||
foo = brotche_mnt_style(&src, &dst);
|
||||
if (foo) {
|
||||
fprintf(stderr, "something weird happen %d\n", foo);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
foo = fimg_export_picture(&dst, outfile, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d exporting to %s\n", foo, outfile);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/* clean the memory */
|
||||
fimg_destroy(&src);
|
||||
fimg_destroy(&dst);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ------------------------------------------------------------------- */
|
||||
@ -1,156 +0,0 @@
|
||||
/*
|
||||
* MOVEPIXELS
|
||||
*
|
||||
* This is experimental, do not use in production !
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include <floatimg.h>
|
||||
|
||||
int verbosity;
|
||||
|
||||
/* ------------------------------------------------------------------- */
|
||||
int displace(FloatImg *psrc, FloatImg *pshift, FloatImg *pdst, float k)
|
||||
{
|
||||
int xd, yd, xs, ys;
|
||||
float rgb[3], disp[3], maxv;
|
||||
float minmax[6];
|
||||
int foo, inside, outside;
|
||||
float dltr, dltg, dltb; /* delta des minmax */
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %p %g )\n", __func__,
|
||||
psrc, pshift, pdst, k);
|
||||
#endif
|
||||
|
||||
if (FIMG_TYPE_RGB != psrc->type) {
|
||||
fprintf(stderr, "%s: bad src type %d\n", __func__, psrc->type);
|
||||
return -7;
|
||||
}
|
||||
if (fimg_images_not_compatible(psrc, pshift)) {
|
||||
fprintf(stderr, "%s: bad shift image %d\n", __func__, pshift->type);
|
||||
return -8;
|
||||
}
|
||||
if (fimg_images_not_compatible(psrc, pdst)) {
|
||||
fprintf(stderr, "%s: bad dst image %d\n", __func__, pdst->type);
|
||||
return -8;
|
||||
}
|
||||
|
||||
foo = fimg_get_minmax_rgb(pshift, minmax);
|
||||
if (verbosity) {
|
||||
fimg_print_minmax(minmax, (char *)__func__);
|
||||
}
|
||||
dltr = minmax[1] - minmax[0];
|
||||
dltg = minmax[3] - minmax[2];
|
||||
dltb = minmax[5] - minmax[4];
|
||||
if (verbosity) fprintf(stderr, "delta shift %f %f %f\n", dltr, dltg, dltb);
|
||||
|
||||
maxv = fimg_get_maxvalue(psrc);
|
||||
inside = outside = 0;
|
||||
|
||||
/* hardcoded parameters. this is very dirty :) */
|
||||
|
||||
#define MULT (140.0)
|
||||
#define OFFS (70.0)
|
||||
|
||||
/* loop over all the pixels of the DESTINATION picture */
|
||||
for (yd=0; yd<pdst->height; yd++) {
|
||||
|
||||
for (xd=0; xd<pdst->width; xd++) {
|
||||
|
||||
fimg_get_rgb(pshift, xd, yd, disp);
|
||||
|
||||
xs = xd + ((disp[0]/dltr*MULT) - OFFS);
|
||||
ys = yd + ((disp[1]/dltb*MULT) - OFFS);
|
||||
|
||||
if ( xs<0 || xs>psrc->width ||
|
||||
ys<0 || ys>psrc->height ) {
|
||||
rgb[0] = rgb[1] = rgb[2] = 0.0;
|
||||
outside++;
|
||||
}
|
||||
else {
|
||||
fimg_get_rgb(psrc, xs, ys, rgb);
|
||||
inside++;
|
||||
}
|
||||
|
||||
fimg_put_rgb(pdst, xd, yd, rgb);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// fprintf(stderr, "%s: inside %d outside %d\n", __func__, inside, outside);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ------------------------------------------------------------------- */
|
||||
/*
|
||||
* High level operateur, taking care of opening/closing
|
||||
* files and doing memory management
|
||||
*/
|
||||
int move_the_pixels(char *infile, char *statfile, char *outfile, int k)
|
||||
{
|
||||
int foo;
|
||||
FloatImg src, shift, dst;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %s %s 0x%04x )\n", __func__,
|
||||
infile, outfile, k);
|
||||
#endif
|
||||
|
||||
/* 'infile' contains the shifting values */
|
||||
foo = fimg_create_from_dump(infile, &shift);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: error loading '%s'\n", __func__, infile);
|
||||
return foo;
|
||||
}
|
||||
|
||||
fimg_clone(&shift, &dst, 0);
|
||||
|
||||
foo = fimg_create_from_dump(statfile, &src);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: error loading 'cumul.fimg'\n", __func__);
|
||||
return foo;
|
||||
}
|
||||
|
||||
foo = displace(&src, &shift, &dst, 42.42);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d in disp map 0\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
foo = fimg_export_picture(&dst, outfile, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d saving result\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ------------------------------------------------------------------- */
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int foo;
|
||||
char *srcfile, *dstfile;
|
||||
|
||||
if (3 != argc) {
|
||||
fprintf(stderr, "usage:\n\t%s src.fimg dst.fimg\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
srcfile = argv[1];
|
||||
dstfile = argv[2];
|
||||
verbosity = 0;
|
||||
|
||||
/* XXX the static picture file MUST be selectable by the yuser ! */
|
||||
foo = move_the_pixels(srcfile, "reference.fimg", dstfile, 3);
|
||||
|
||||
fprintf(stderr, "move pixels %s -> %s = %d\n", srcfile, dstfile, foo);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ------------------------------------------------------------------- */
|
||||
@ -1,113 +0,0 @@
|
||||
/*
|
||||
* another ugly experiment (please explain)
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------- */
|
||||
|
||||
int triplane_muxer(FloatImg *sr, FloatImg *sg, FloatImg *sb,
|
||||
FloatImg *dst)
|
||||
{
|
||||
int sz;
|
||||
|
||||
if (FIMG_TYPE_RGB != dst->type) {
|
||||
fprintf(stderr, "%s: dst picz must be RGB, was %d\n",
|
||||
__func__, dst->type);
|
||||
return -99;
|
||||
}
|
||||
|
||||
if ( fimg_images_not_compatible(sr, sg) ||
|
||||
fimg_images_not_compatible(sr, sb) ||
|
||||
fimg_images_not_compatible(sr, dst) ) {
|
||||
fprintf(stderr, "%s: compatibility error\n", __func__);
|
||||
return -2;
|
||||
}
|
||||
|
||||
sz = sr->width * sr->height * sizeof(float);
|
||||
|
||||
memcpy(dst->R, sr->R, sz);
|
||||
memcpy(dst->G, sg->G, sz);
|
||||
memcpy(dst->B, sb->B, sz);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------- */
|
||||
int try_this_muxplane(char *fr, char *fg, char *fb, char *dst, int flags)
|
||||
{
|
||||
int foo;
|
||||
FloatImg imr, img, imb, dest;
|
||||
|
||||
fprintf(stderr, "muxing: %s %s %s -> %s\n", fr, fg, fb, dst);
|
||||
|
||||
if (flags) {
|
||||
fprintf(stderr, "%s: flag non 0 ?\n", __FILE__);
|
||||
}
|
||||
|
||||
foo = fimg_create_from_dump(fr, &imr);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d loading %s\n", __func__, foo, fr);
|
||||
return -1;
|
||||
}
|
||||
foo = fimg_create_from_dump(fg, &img);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d loading %s\n", __func__, foo, fg);
|
||||
return -1;
|
||||
}
|
||||
foo = fimg_create_from_dump(fb, &imb);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d loading %s\n", __func__, foo, fb);
|
||||
return -1;
|
||||
}
|
||||
|
||||
fimg_clone(&imr, &dest, 0);
|
||||
|
||||
foo = triplane_muxer(&imr, &img, &imb, &dest);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
foo = fimg_export_picture(&dest, dst, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d exporting to %s\n", __func__, foo, dst);
|
||||
return foo;
|
||||
}
|
||||
|
||||
fimg_destroy(&imr); fimg_destroy(&img);
|
||||
fimg_destroy(&imb); fimg_destroy(&dest);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------- */
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int foo;
|
||||
|
||||
if (5 != argc) {
|
||||
fprintf(stderr, "ERROR: %s need four fimg files arguments\n",
|
||||
argv[0]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* and now, we have to decipher options on the
|
||||
* command line.
|
||||
*/
|
||||
|
||||
foo = try_this_muxplane(argv[1], argv[2], argv[3], argv[4], 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "oups %d\n", foo);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------- */
|
||||
@ -1,49 +0,0 @@
|
||||
/*
|
||||
* tests du systeme de cache
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
#include "cachengn.h"
|
||||
|
||||
int verbosity;
|
||||
|
||||
#define IMGW 320
|
||||
#define IMGH 240
|
||||
|
||||
#define SIZE 5 // number of slots
|
||||
#define NBRI 1000
|
||||
|
||||
/* ------------------------------------------------------------ */
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int foo;
|
||||
FloatImg *picz;
|
||||
char *fname = "quux.fimg";
|
||||
|
||||
fprintf(stderr, "\nTest of the cache engin - %s %s\n",
|
||||
__DATE__, __TIME__);
|
||||
cachengn_print_version(1);
|
||||
|
||||
foo = init_empty_cache(IMGW, IMGH, SIZE, NBRI);
|
||||
fprintf(stderr, " init_empty_cache --> %d\n", foo);
|
||||
|
||||
foo = liste_le_cache((unsigned int)'U');
|
||||
fprintf(stderr, " liste le cache --> %d\n", foo);
|
||||
|
||||
picz = give_me_thiz_picz(fname, 0);
|
||||
if (NULL == picz) {
|
||||
fprintf(stderr, " error 'givemeapicz' on '%s'\n", fname);
|
||||
}
|
||||
|
||||
picz = give_me_thiz_picz(fname, 0);
|
||||
if (NULL == picz) {
|
||||
fprintf(stderr, " error 'givemeapicz' on '%s'\n", fname);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ------------------------------------------------------------ */
|
||||
|
||||
@ -1,24 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
GRABOPT=" -vv -d /dev/video0 -n 400 -p 0.5 -u "
|
||||
SPOOL=${HOME}/TMP
|
||||
|
||||
echo ; echo ; echo
|
||||
|
||||
for capture in red green blue
|
||||
do
|
||||
image=${SPOOL}/${capture}.fimg
|
||||
echo grabbing $image
|
||||
grabvidseq ${GRABOPT} -o $image
|
||||
echo
|
||||
done
|
||||
|
||||
./muxplanes "${SPOOL}/red.fimg" \
|
||||
"${SPOOL}/green.fimg" \
|
||||
"${SPOOL}/blue.fimg" \
|
||||
yo.fimg
|
||||
|
||||
echo $0 "got a" $?
|
||||
|
||||
fimgstats -v yo.fimg
|
||||
|
||||
@ -7,12 +7,11 @@ COPT = -g -fpic -no-pie -Wall -DDEBUG_LEVEL=0 -Werror=parentheses
|
||||
LIBS = ../libfloatimg.a -ltiff -lpnglite -lm -lz -lcfitsio
|
||||
|
||||
OBJS = fifo.o sfx.o crapulator.o glitches.o metriques.o \
|
||||
filterstack.o single.o utilfuncs.o
|
||||
filterstack.o single.o
|
||||
|
||||
DEPS = ../floatimg.h \
|
||||
../libfloatimg.a \
|
||||
fifo.h crapulator.h metriques.h glitches.h sfx.h \
|
||||
filterstack.h crapdef.h crapstr.h single.h utilfuncs.h
|
||||
filterstack.h crapdef.h crapstr.h single.h
|
||||
|
||||
all: fonderie interpolator singlepass t
|
||||
|
||||
@ -41,19 +40,19 @@ singlepass: singlepass.c ${DEPS} ${OBJS} Makefile
|
||||
# some files are magically generated, sorry.
|
||||
#
|
||||
crapdef.h: crapulors.liste Makefile craplist2h.awk
|
||||
< $< ./craplist2h.awk > $@
|
||||
./craplist2h.awk < $< | tee $@
|
||||
|
||||
crapstr.h: crapulors.liste Makefile craplist2str.awk
|
||||
< $< ./craplist2str.awk > $@
|
||||
./craplist2str.awk < $< | tee $@
|
||||
|
||||
# ---------------------------------------------------------
|
||||
#
|
||||
# a lot of silly functions
|
||||
#
|
||||
crapulator.o: crapulator.c $(DEPS) Makefile
|
||||
crapulator.o: crapulator.c ${DEPS} Makefile
|
||||
gcc ${COPT} -c $<
|
||||
|
||||
fifo.o: fifo.c fifo.h $(DEPS) Makefile
|
||||
fifo.o: fifo.c fifo.h Makefile
|
||||
gcc ${COPT} -c $<
|
||||
|
||||
sfx.o: sfx.c ${DEPS} Makefile
|
||||
@ -71,7 +70,4 @@ metriques.o: metriques.c metriques.h Makefile
|
||||
glitches.o: glitches.c glitches.h Makefile
|
||||
gcc ${COPT} -c $<
|
||||
|
||||
utilfuncs.o: utilfuncs.c utilfuncs.h Makefile
|
||||
gcc ${COPT} -c $<
|
||||
|
||||
# ---------------------------------------------------------
|
||||
@ -3,14 +3,12 @@
|
||||
Avec toutes ces fonctions disponibles et `grabvidseq`, nous
|
||||
savons faire des images **floues**. L'étape suivante, les plus
|
||||
pervers d'entre vous le savent déja, est celle de la création
|
||||
de **films flous** dans le domaine spatio-temporel.
|
||||
de **films flous** dans le domaine spacio-temporel.
|
||||
|
||||
À l'heure actuelle, il y a plusieurs programmes distincts. Le premier
|
||||
(fonderie) fait une moyenne mobile sur N images consécutives,
|
||||
le second (interpolator) fait un fondu-enchainé de N pas
|
||||
entre deux images consécutives,
|
||||
et le troisième (singlepass) fait d'autres trucs, comme
|
||||
répéter N fois un image pour avoir une vidéo sacadée.
|
||||
et le second (interpolator) fait un fondu-enchainé de N pas
|
||||
entre deux images consécutives.
|
||||
|
||||
Mais avant et après un de ces deux traitements, il y a des chaines
|
||||
de filtres...
|
||||
@ -22,15 +20,16 @@ destinés à augmenter la kitchitude du produit final. Ils peuvent être chainé
|
||||
les uns après les autres, à l'entrée et à la sortie du process
|
||||
de floutagement.
|
||||
|
||||
Ces filtres ont chacun un nom, utilisable dans une chaine de filtres.
|
||||
Ces filtres ont chacun un nom et un numéro. que l'on peut (en théorie)
|
||||
utiliser indistinctement dans une chaine de filtres.
|
||||
L'option `-L` de ces logiciels permet d'obtenir la liste des filtres.
|
||||
Pour ne rien filtrer, utilisez le filtre `none`, il est là pour ça.
|
||||
|
||||
Une chaine de filtres est constituée d'une liste de nom
|
||||
Une chaine de filtres est constituée d'une liste de nom ou de numéro
|
||||
de filtre, séparés par le caractère `:`, une façon de faire très
|
||||
classique dans notre univers, en fait.
|
||||
classique dans notre univers, en fait. Et si on veut prendre des risques,
|
||||
on doit continuer à appeler les filtres par leur numéro, jdçjdr.
|
||||
|
||||
`mirsplit:ctr2x2:killlines`
|
||||
`mirsplit:ctr2x2:3:killlines`
|
||||
|
||||
Nous allons donc voir quelques exemples un peu plus loin.
|
||||
|
||||
@ -71,14 +70,12 @@ GRABDIR="/spool/tth/fonderie"
|
||||
FONDEUR="$HOME/Devel/FloatImg/Fonderie/fonderie"
|
||||
GLOB=${GRABDIR}'/?????.fimg'
|
||||
|
||||
${FONDEUR} -I "$GLOB" -E cos01:trinitron -F classtrial -T 30
|
||||
${FONDEUR} -I "$GLOB" -E cos01:25 -T 30 -F 2:classtrial
|
||||
```
|
||||
|
||||
Par défaut le répertoire où sont exportées les images est nommé
|
||||
`p8/` et il doit être là, c'est donc à vous de le créer.
|
||||
Votre machine va maintenant mouliner avec entrain et persévérance,
|
||||
puis
|
||||
ensuite il vous suffira d'encoder toutes les images générées dans
|
||||
ensuite il suffit d'encoder toutes les images générées dans
|
||||
`p8/` (répertoire de sortie par défaut)
|
||||
avec une incantation de ffmpeg :
|
||||
|
||||
@ -98,7 +95,7 @@ assez rudimentaire, avec un paramétrage simpliste, et un manque
|
||||
criant de documentation...
|
||||
|
||||
Dans la même équipe, vous pouvez aussi aller contempler `glitches.c`
|
||||
pour voir le genre de traitement que l'on fait subir à nos pixels
|
||||
pour voir le genre de traitement que l'on fait subir à nox pixels
|
||||
flottants.
|
||||
|
||||
## Interpolator
|
||||
@ -115,8 +112,8 @@ usage:
|
||||
interpolator [options] <inglob> <outdir> <nbsteep>
|
||||
options:
|
||||
-S nn mysterious sort
|
||||
-E foo:bla:kr input filter chain
|
||||
-F name:just output filter chain
|
||||
-E i:bla:k input filter chain
|
||||
-F name:j output filter chain
|
||||
-L list available filters
|
||||
-v increase verbosity
|
||||
```
|
||||
@ -133,15 +130,12 @@ usage:
|
||||
-F define:the:filter:chain
|
||||
-g input glob pattern
|
||||
-L list available filters
|
||||
-r N repetiiing factor
|
||||
-O /output/directory
|
||||
-v spit more messages
|
||||
```
|
||||
|
||||
## Conclusion
|
||||
|
||||
Tout cela est bien rigolo :)
|
||||
|
||||
|
||||
**Use the source, Luke**
|
||||
|
||||
@ -6,19 +6,18 @@
|
||||
#
|
||||
|
||||
BEGIN {
|
||||
print "// -------------------------------------"
|
||||
print "// -----------------------------------"
|
||||
print "// generated file, do not edit by hand !"
|
||||
print "// -------------------------------------"
|
||||
print "// -----------------------------------"
|
||||
}
|
||||
|
||||
# $1 is the badly brain-designed numeric id
|
||||
# $2 is the user name of the filter
|
||||
|
||||
{
|
||||
name = sprintf("CR_%s", $2)
|
||||
printf "#define %-15s (%d)\n", name, $1
|
||||
printf "#define CR_%s (%d)\n", $2, $1
|
||||
}
|
||||
|
||||
END {
|
||||
print "\n// generated file, do not edit by hand !"
|
||||
print "// generated file, do not edit by hand !"
|
||||
}
|
||||
27
extras/Fonderie/craplist2str.awk
Executable file
27
extras/Fonderie/craplist2str.awk
Executable file
@ -0,0 +1,27 @@
|
||||
#!/usr/bin/awk -f
|
||||
|
||||
#
|
||||
# this utility script make a file who
|
||||
# is includet by 'crapulator.c'
|
||||
#
|
||||
BEGIN {
|
||||
print "// -----------------------------------"
|
||||
print "// generated file, do not edit by hand";
|
||||
print "// -----------------------------------"
|
||||
print "Crapulor CrapL[] = {";
|
||||
}
|
||||
|
||||
# $1 is the badly brain-designed numeric id
|
||||
# $2 is the user name of the filter
|
||||
# $3 and $4 are two not used parameters
|
||||
#
|
||||
{
|
||||
printf " { CR_%s, \"%s\", %d, %f }, // id=%d\n",
|
||||
$2, $2, $3, $4, $1;
|
||||
}
|
||||
|
||||
END {
|
||||
print " { -1, NULL }"
|
||||
print " };"
|
||||
print "// generated file, do not edit by hand"
|
||||
}
|
||||
@ -4,7 +4,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
@ -82,7 +81,7 @@ FloatImg img;
|
||||
int foo, retval;
|
||||
FimgFilter3x3 *pfiltre;
|
||||
|
||||
static FimgFilter3x3 lowpass = {
|
||||
FimgFilter3x3 lowpass = {
|
||||
{
|
||||
1.0, 2.0, 1.0,
|
||||
2.0, 4.0, 2.0,
|
||||
@ -91,8 +90,7 @@ static FimgFilter3x3 lowpass = {
|
||||
16.0, 0.0
|
||||
};
|
||||
|
||||
static FimgFilter3x3 hipass = {
|
||||
/* there was a bug with this filter */
|
||||
FimgFilter3x3 hipass = {
|
||||
{
|
||||
-1.0, -1.0, -1.0,
|
||||
-1.0, 9.0, -1.0,
|
||||
@ -101,12 +99,11 @@ static FimgFilter3x3 hipass = {
|
||||
1.0, 0.0
|
||||
};
|
||||
|
||||
static FimgFilter3x3 diagonal = {
|
||||
/* there was a bug with this filter */
|
||||
FimgFilter3x3 diagonal = {
|
||||
{
|
||||
4.0, 1.0, 0.0,
|
||||
2.0, 1.0, 0.0,
|
||||
1.0, 0.0, -1.0,
|
||||
0.0, -1.0, -4.0,
|
||||
0.0, -1.0, -2.0,
|
||||
},
|
||||
1.0, 0.0
|
||||
};
|
||||
@ -154,150 +151,6 @@ fimg_destroy(&img);
|
||||
return retval;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
int run_killrgb_0(FloatImg *img, int k)
|
||||
{
|
||||
FloatImg tmp;
|
||||
int ret;
|
||||
|
||||
// fprintf(stderr, "----> %s\n", __func__);
|
||||
|
||||
memset(&tmp, 0, sizeof(FloatImg));
|
||||
|
||||
fimg_clone(img, &tmp, 0);
|
||||
ret = fimg_killrgb_v(img, &tmp, k);
|
||||
fimg_copy_data(&tmp, img);
|
||||
fimg_destroy(&tmp);
|
||||
|
||||
// fprintf(stderr, "%s ---->\n", __func__);
|
||||
|
||||
return ret;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
static int run_pixelize_0(FloatImg *img, int k)
|
||||
{
|
||||
FloatImg tmp;
|
||||
int ret;
|
||||
|
||||
memset(&tmp, 0, sizeof(FloatImg));
|
||||
fimg_clone(img, &tmp, 0);
|
||||
ret = fimg_pixelize_h_0(img, &tmp, k);
|
||||
fimg_copy_data(&tmp, img);
|
||||
fimg_destroy(&tmp);
|
||||
|
||||
return ret;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
static int run_pixelize_random(FloatImg *img, int k)
|
||||
{
|
||||
FloatImg tmp;
|
||||
int ret;
|
||||
|
||||
memset(&tmp, 0, sizeof(FloatImg));
|
||||
fimg_clone(img, &tmp, 0);
|
||||
ret = fimg_pixelize_h_rnd(img, &tmp, k);
|
||||
if (verbosity > 1) fprintf(stderr, "in %s, pixelize H rnd -> %d\n",
|
||||
__func__, ret);
|
||||
fimg_copy_data(&tmp, img);
|
||||
fimg_destroy(&tmp);
|
||||
|
||||
return ret;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/* added Mon Apr 1 15:56:54 UTC 2024 */
|
||||
static int run_triptyq(FloatImg *img, int k)
|
||||
{
|
||||
FloatImg tmp;
|
||||
int ret;
|
||||
memset(&tmp, 0, sizeof(FloatImg));
|
||||
fimg_clone(img, &tmp, 0);
|
||||
ret = fimg_make_triptyq(img, &tmp, k);
|
||||
fimg_copy_data(&tmp, img);
|
||||
fimg_destroy(&tmp);
|
||||
|
||||
return ret;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
static int run_decomprgbz_color(FloatImg *img, int k)
|
||||
{
|
||||
FloatImg tmp;
|
||||
int ret;
|
||||
|
||||
memset(&tmp, 0, sizeof(FloatImg));
|
||||
fimg_clone(img, &tmp, 0);
|
||||
ret = fimg_decomp_rgbz_color(img, &tmp, k);
|
||||
fimg_copy_data(&tmp, img);
|
||||
fimg_destroy(&tmp);
|
||||
|
||||
return ret;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/* nouveau 14 mai 2022 */
|
||||
static int run_gr2popcol(FloatImg *img, int k)
|
||||
{
|
||||
FloatImg tmp;
|
||||
int ret;
|
||||
memset(&tmp, 0, sizeof(FloatImg));
|
||||
fimg_clone(img, &tmp, 0);
|
||||
ret = graylevel2popcolors(img, &tmp, k);
|
||||
fimg_copy_data(&tmp, img);
|
||||
fimg_destroy(&tmp);
|
||||
|
||||
return ret;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/* new Sun Feb 12 11:30:02 CET 2023 */
|
||||
static int run_rndfluffy(FloatImg *img, int k)
|
||||
{
|
||||
FloatImg tmp;
|
||||
int ret;
|
||||
memset(&tmp, 0, sizeof(FloatImg));
|
||||
fimg_clone(img, &tmp, 0);
|
||||
ret = fimg_make_rndfluffy_lines(img, &tmp, k);
|
||||
fimg_copy_data(&tmp, img);
|
||||
fimg_destroy(&tmp);
|
||||
|
||||
return ret;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
static int run_decomprgbz_gray(FloatImg *img, int k)
|
||||
{
|
||||
FloatImg tmp;
|
||||
int ret;
|
||||
|
||||
/* ugly code here */
|
||||
memset(&tmp, 0, sizeof(FloatImg));
|
||||
fimg_clone(img, &tmp, 0);
|
||||
ret = fimg_decomp_rgbz_gray(img, &tmp, k);
|
||||
fimg_copy_data(&tmp, img);
|
||||
fimg_destroy(&tmp);
|
||||
|
||||
return ret;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/* new Sun Jul 16 11:27:43 UTC 2023 */
|
||||
int run_suprbg(FloatImg *img, int notused)
|
||||
{
|
||||
FloatImg tmp;
|
||||
int ret;
|
||||
|
||||
if (notused) {
|
||||
fprintf(stderr, "FATAL: invalid notused in %s\n", __func__);
|
||||
abort();
|
||||
}
|
||||
|
||||
/* ugly code here */
|
||||
memset(&tmp, 0, sizeof(FloatImg));
|
||||
fimg_clone(img, &tmp, 0);
|
||||
ret = poke_sup_rb_g(img, &tmp);
|
||||
if (ret) {
|
||||
fprintf(stderr, "%s: ret = %d\n", __func__, ret);
|
||||
}
|
||||
fimg_copy_data(&tmp, img);
|
||||
fimg_destroy(&tmp);
|
||||
|
||||
return ret;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/*
|
||||
* This is the main filter engine used both for input and
|
||||
* output processing. It can be called by the filterstack
|
||||
@ -416,28 +269,19 @@ switch (idFx) {
|
||||
retval = fimg_power_2(image, image, 1000.0);
|
||||
break;
|
||||
|
||||
case CR_triplemul:
|
||||
retval = fimg_sfx_triplemul(image, image, 0);
|
||||
break;
|
||||
|
||||
/* here are the glitches */
|
||||
case CR_bsombra: /* experiment ! */
|
||||
retval = des_bords_sombres_a(image, 160);
|
||||
break;
|
||||
case CR_bsombrb: /* experiment ! */
|
||||
retval = des_bords_sombres_b(image, 120);
|
||||
retval = des_bords_sombres_b(image, 160);
|
||||
break;
|
||||
|
||||
case CR_vsglitch:
|
||||
/* please make this function more tweakable */
|
||||
retval = vertical_singlitch(image, 290+rand()%45,
|
||||
fval, 0.19, 0);
|
||||
break;
|
||||
|
||||
case CR_crumphard: /* new june 1st 2021, in the bibcave */
|
||||
retval = fimg_crump_hard(image, image, fval, 0);
|
||||
break;
|
||||
|
||||
case CR_rndblks:
|
||||
retval = random_blocks(image, 70);
|
||||
break;
|
||||
@ -454,72 +298,22 @@ switch (idFx) {
|
||||
retval = plot_multidots(image, 42);
|
||||
break;
|
||||
|
||||
case CR_message:
|
||||
fprintf(stderr, "### msg from pid %d, fval=%f ###\n",
|
||||
getpid(), fval);
|
||||
/* here, we can display stats ! */
|
||||
fimg_describe(image, "in crapulator");
|
||||
retval = 0;
|
||||
break;
|
||||
|
||||
case CR_nothing:
|
||||
retval = do_something(image, 3);
|
||||
break;
|
||||
|
||||
case CR_killrgb0:
|
||||
retval = run_killrgb_0(image, 0);
|
||||
break;
|
||||
|
||||
case CR_pixelizh:
|
||||
retval = run_pixelize_0(image, 8);
|
||||
break;
|
||||
case CR_pixelizv:
|
||||
retval = run_pixelize_0(image, 32);
|
||||
break;
|
||||
|
||||
case CR_pixelrand:
|
||||
retval = run_pixelize_random(image, 16);
|
||||
break;
|
||||
|
||||
case CR_splitlevel:
|
||||
retval = fimg_split_level(image, image, 0);
|
||||
break;
|
||||
|
||||
case CR_decrgbzc:
|
||||
retval = run_decomprgbz_color(image, 0);
|
||||
break;
|
||||
case CR_decrgbzg:
|
||||
retval = run_decomprgbz_gray(image, 0);
|
||||
break;
|
||||
|
||||
case CR_hilightr:
|
||||
retval = fimg_highlight_color(image, image, 'R', 1.717);
|
||||
break;
|
||||
|
||||
case CR_gr2popcol:
|
||||
retval = run_gr2popcol(image, -1);
|
||||
break;
|
||||
|
||||
case CR_fluffy:
|
||||
retval = run_rndfluffy(image, 75);
|
||||
break;
|
||||
|
||||
case CR_suprbg:
|
||||
retval = run_suprbg(image, 0);
|
||||
break;
|
||||
|
||||
case CR_thermocol:
|
||||
/* new Wed Mar 20 19:42:42 UTC 2024 */
|
||||
retval = fimg_auto_thermique(image, image, 0);
|
||||
break;
|
||||
|
||||
case CR_triptyq:
|
||||
/* added Mon Apr 1 15:52:32 UTC 2024*/
|
||||
retval = run_triptyq(image, 0);
|
||||
break;
|
||||
|
||||
case CR_togray:
|
||||
retval = fimg_to_gray(image);
|
||||
break;
|
||||
|
||||
case CR_shift0:
|
||||
/* added Sun Sep 29 16:55:54 UTC 2024 */
|
||||
retval = fimg_auto_shift_to_zero(image, image);
|
||||
// fprintf(stderr, "******** Shift Zero -> %d\n", retval);
|
||||
break;
|
||||
|
||||
default :
|
||||
fprintf(stderr, "%s : effect #%d invalid\n",
|
||||
__func__, idFx);
|
||||
@ -555,26 +349,14 @@ void list_crapulors(char *texte)
|
||||
int idx;
|
||||
|
||||
#define OUT stdout
|
||||
|
||||
if (verbosity) {
|
||||
fprintf(stderr, "We have around %ld filters now !\n", NBCRAP);
|
||||
}
|
||||
|
||||
if (NULL!=texte && verbosity)
|
||||
fprintf(OUT, " _________ %s _________\n", texte);
|
||||
|
||||
fprintf(OUT, "______________. %s\n", texte);
|
||||
for (idx=0; CrapL[idx].id!=-1; idx++) {
|
||||
if (verbosity) {
|
||||
fprintf(OUT, " %-12s | %4d | %5d | %8.3f\n",
|
||||
CrapL[idx].name,
|
||||
CrapL[idx].id,
|
||||
CrapL[idx].ipar,
|
||||
CrapL[idx].fpar);
|
||||
}
|
||||
else {
|
||||
fprintf(OUT, "%s\n", CrapL[idx].name);
|
||||
}
|
||||
}
|
||||
#undef OUT
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
@ -27,26 +27,10 @@
|
||||
26 rndblks 1 1.0
|
||||
27 shiftln0 1 1.0
|
||||
28 qsortrgb 2 1.0
|
||||
29 triplemul 3 1.0
|
||||
30 multidots 100 1.333
|
||||
31 diagonal 1 1.0
|
||||
32 vsglitch 1 1.0
|
||||
33 crumphard 1 1.0
|
||||
42 nothing 42 3.1415926
|
||||
43 killrgb0 1 9
|
||||
45 hilightr 1 1.717
|
||||
46 pixelizh 1 1.111
|
||||
47 pixelizv 1 1.111
|
||||
48 pixelrand 1 1
|
||||
49 splitlevel 1 1
|
||||
50 decrgbzc 1 99
|
||||
51 decrgbzg 1 99
|
||||
60 gr2popcol 1 99
|
||||
61 fluffy 1 0.12
|
||||
62 suprbg 1 0
|
||||
80 thermocol 1 0
|
||||
81 triptyq 1 0
|
||||
90 togray 1 0
|
||||
91 shift0 1 0
|
||||
99 message 1 1.0
|
||||
-1 end 1 1.0
|
||||
|
||||
@ -5,7 +5,6 @@
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <malloc.h>
|
||||
|
||||
@ -26,7 +25,7 @@ extern int verbosity;
|
||||
static A_Fifo g_fifo;
|
||||
|
||||
/* -------------------------------------------------------------- */
|
||||
static inline int big_adder(FloatImg *from, FloatImg *to)
|
||||
static int big_adder(FloatImg *from, FloatImg *to)
|
||||
{
|
||||
int size, idx;
|
||||
|
||||
@ -87,10 +86,10 @@ return 0;
|
||||
*/
|
||||
int export_fifo(char *fname, int notused)
|
||||
{
|
||||
int foo;
|
||||
int foo, type;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( '%s' %d )\n", __func__, fname, notused);
|
||||
fprintf(stderr, ">>> %s ( '%s' %d )\n", __func__, fname, step);
|
||||
#endif
|
||||
|
||||
foo = faire_la_somme(&g_fifo, NULL, 1);
|
||||
@ -118,7 +117,7 @@ return 0;
|
||||
int insert_picture(FloatImg *src)
|
||||
{
|
||||
FloatImg *dst;
|
||||
int nbre;
|
||||
int nbre, foo;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p )\n", __func__, src);
|
||||
@ -4,7 +4,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <alloca.h>
|
||||
@ -4,13 +4,11 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <glob.h>
|
||||
#include "../floatimg.h"
|
||||
|
||||
#include "utilfuncs.h"
|
||||
#include "fifo.h"
|
||||
#include "glitches.h"
|
||||
#include "crapulator.h"
|
||||
@ -109,7 +107,7 @@ fprintf(stderr, "glob '%s' -> %d, %d files found\n", pattern, foo,
|
||||
/* get the size of the inputs images */
|
||||
foo = fimg_fileinfos(globbuf.gl_pathv[0], datas);
|
||||
width = datas[0]; height = datas[1];
|
||||
if (verbosity) fprintf(stderr, "first image size %dx%d\n", width, height);
|
||||
fprintf(stderr, "first image size %dx%d\n", width, height);
|
||||
|
||||
fimg_create(&input, width, height, 3);
|
||||
|
||||
@ -121,10 +119,10 @@ if (foo) {
|
||||
exit(1);
|
||||
}
|
||||
maxvalue = fimg_get_maxvalue(&input);
|
||||
if (verbosity) fprintf(stderr, "first image maxvalue %f\n", maxvalue);
|
||||
fprintf(stderr, "first image maxvalue %f\n", maxvalue);
|
||||
|
||||
foo = create_fifo(szfifo, width, height, FIMG_TYPE_RGB);
|
||||
if (verbosity) fprintf(stderr, "init fifo (%d slots) = %d\n", szfifo, foo);
|
||||
fprintf(stderr, "init fifo (%d slots) --> %d\n", szfifo, foo);
|
||||
|
||||
/* XXX inject a few strange pics in the fifo */
|
||||
insert_blank(&input, blk, outdir);
|
||||
@ -187,12 +185,10 @@ puts("\t-F\toutput:filter:chain");
|
||||
// puts("\t-g\tconvert to gray");
|
||||
puts("\t-I\tinput glob pattern");
|
||||
puts("\t-L\tlist available filters");
|
||||
puts("\t-O\toutput directory (default p8/)");
|
||||
puts("\t-O\toutput directory");
|
||||
puts("\t-T\tfifo size");
|
||||
puts("\t-v\tincrease verbosity");
|
||||
|
||||
if (verbosity) { puts(""); fimg_print_version(2); puts(""); }
|
||||
|
||||
exit(0);
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
@ -203,12 +199,13 @@ int fifosize = 10;
|
||||
char *in_pattern = "capture/?????.fimg";
|
||||
char *out_dir = "p8";
|
||||
int outfmt = FILE_TYPE_PNG;
|
||||
int blanks = 10;
|
||||
int blanks = 20;
|
||||
char *InFchain = "none";
|
||||
char *OutFchain = "none";
|
||||
|
||||
fprintf(stderr, "*** %s\n\tcompiled %s, %s, pid %d\n",
|
||||
argv[0], __DATE__, __TIME__, getpid());
|
||||
fimg_print_version(2);
|
||||
|
||||
while ((opt = getopt(argc, argv, "B:E:F:ghI:LO:T:vw:x:")) != -1) {
|
||||
switch(opt) {
|
||||
@ -231,7 +228,6 @@ while ((opt = getopt(argc, argv, "B:E:F:ghI:LO:T:vw:x:")) != -1) {
|
||||
break;
|
||||
case 'v': verbosity++;
|
||||
break;
|
||||
default: exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
@ -240,16 +236,6 @@ if (verbosity) {
|
||||
fprintf(stderr, "\toutput dir '%s'\n", out_dir);
|
||||
fprintf(stderr, "\tsrc filter '%s'\n", InFchain);
|
||||
fprintf(stderr, "\tout filter '%s'\n", OutFchain);
|
||||
fprintf(stderr, "\tfifo size %d\n", fifosize);
|
||||
}
|
||||
/*
|
||||
* check for the export directory
|
||||
*/
|
||||
foo = check_if_export_dir_is_valid(out_dir, 0);
|
||||
if ( !foo ) {
|
||||
fprintf(stderr, "** export dir (%s) not valid\n", out_dir);
|
||||
fprintf(stderr, "** may be you have to create it ?\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
foo = parse_filter_chain(0, InFchain);
|
||||
@ -271,7 +257,7 @@ if (verbosity > 1) {
|
||||
|
||||
foo = demarre_la_machine(in_pattern, out_dir, fifosize, outfmt, blanks);
|
||||
|
||||
fprintf(stderr, "retour du bigrun de la machine -> %d\n", foo);
|
||||
fprintf(stderr, "retour du big-run de la machine -> %d\n", foo);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -7,7 +7,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
@ -151,38 +150,36 @@ int pass, szimg, osrc, odst;
|
||||
szimg = picture->width * picture->height;
|
||||
|
||||
for (pass=0; pass<szimg/32; pass++) {
|
||||
|
||||
osrc = rand() % szimg;
|
||||
odst = rand() % szimg;
|
||||
picture->R[odst] = (picture->R[osrc] + picture->R[odst]) / 2.0;
|
||||
picture->G[odst] = (picture->G[osrc] + picture->G[odst]) / 2.0;
|
||||
picture->B[odst] = (picture->B[osrc] + picture->B[odst]) / 2.0;
|
||||
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/*
|
||||
* FIXME XXX
|
||||
*/
|
||||
int random_blocks(FloatImg *picture, int percent)
|
||||
{
|
||||
int x, y;
|
||||
|
||||
if ( (picture->width%16) || (picture->height%16) )
|
||||
{
|
||||
fprintf(stderr, "WARNING %s: %dx%d bad dims\n", __func__,
|
||||
fprintf(stderr, "%s: %d%d bad dims\n", __func__,
|
||||
picture->width, picture->height);
|
||||
// return -1;
|
||||
}
|
||||
|
||||
for (y=16; y<picture->height-16; y+=16) {
|
||||
for (x=16; x<picture->width-16; x+=16) {
|
||||
for (y=0; y<picture->height; y+=16) {
|
||||
for (x=0; x<picture->width; x+=16) {
|
||||
if (percent < (rand()%100) ) {
|
||||
un_petit_flou_8x8(picture, x, y);
|
||||
un_petit_flou_8x8(picture, x+8, y);
|
||||
un_petit_flou_8x8(picture, x, y+8);
|
||||
un_petit_flou_8x8(picture, x+8, y+8);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -10,14 +10,12 @@
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <glob.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
#include "utilfuncs.h"
|
||||
#include "fifo.h"
|
||||
#include "glitches.h"
|
||||
#include "crapulator.h"
|
||||
@ -55,14 +53,10 @@ char *filename;
|
||||
IdxValue *idxvalues;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d %p)\n", __func__, ptr_glob,
|
||||
ptr_idxval, method, p_average);
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, ptr_glob,
|
||||
ptr_idxval, method);
|
||||
#endif
|
||||
|
||||
if (0==method && verbosity) {
|
||||
fprintf(stderr, "\tWTF? in %s, sort method was ZERO?\n", __func__);
|
||||
}
|
||||
|
||||
nombre = ptr_glob->gl_pathc;
|
||||
|
||||
/* allocate the array for the sorting action */
|
||||
@ -71,7 +65,7 @@ if (NULL==idxvalues) {
|
||||
fprintf(stderr, "MEMORY ERROR in %s\n", __func__);
|
||||
exit(1);
|
||||
}
|
||||
// fprintf(stderr, "IdxValues array at %p\n", idxvalues);
|
||||
fprintf(stderr, "IdxValues array at %p\n", idxvalues);
|
||||
|
||||
*ptr_idxval = idxvalues;
|
||||
average = 0.0;
|
||||
@ -109,7 +103,7 @@ if (verbosity > 1) {
|
||||
average /= (double)nombre;
|
||||
*p_average = average;
|
||||
|
||||
fprintf(stderr, "\naverage of ??? is %f\n", average);
|
||||
fprintf(stderr, "\naverage %f\n", average);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -127,7 +121,7 @@ int foo, idx, ipng, w, h, step;
|
||||
int curpix;
|
||||
int iarray[3];
|
||||
char *cptr, line[200];
|
||||
float coef;
|
||||
float coef, value;
|
||||
double meanmetric;
|
||||
IdxValue *idx_values; /* gni? */
|
||||
|
||||
@ -141,8 +135,8 @@ foo = glob(pattern, 0, NULL, &globbuf);
|
||||
fprintf(stderr, "globbing '%s' -> %d, %d files found\n",
|
||||
pattern, foo, (int)globbuf.gl_pathc);
|
||||
if (0 == globbuf.gl_pathc) {
|
||||
fprintf(stderr, "%s : no file found, ABEND\n", __func__);
|
||||
exit(1);
|
||||
fprintf(stderr, "%s : no file found, aborting\n", __func__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
idx_values = NULL;
|
||||
@ -160,7 +154,7 @@ if (FIMG_TYPE_RGB != iarray[2]) {
|
||||
}
|
||||
|
||||
w = iarray[0], h = iarray[1];
|
||||
if (verbosity) fprintf(stderr, "first image size : %dx%d\n", w, h);
|
||||
fprintf(stderr, "first image size : %dx%d\n", w, h);
|
||||
|
||||
fimg_create(&A, w, h, 3); pFirst = &A; fimg_clear(&A);
|
||||
fimg_create(&B, w, h, 3); pSecond = &B; fimg_clear(&B);
|
||||
@ -177,10 +171,10 @@ for (idx=0; idx<globbuf.gl_pathc; idx++) {
|
||||
(int)globbuf.gl_pathc, cptr);
|
||||
foo = fimg_load_from_dump(cptr, &B);
|
||||
if (foo) {
|
||||
fprintf(stderr, "\n%s: load %s from dump -> %d\n", __func__,
|
||||
cptr, foo);
|
||||
fprintf(stderr, "load %s from dump -> %d\n", cptr, foo);
|
||||
continue;
|
||||
}
|
||||
value = idx_values[idx].value;
|
||||
|
||||
/* here was the input filter */
|
||||
foo = filterstack_run(0, &B, 0);
|
||||
@ -241,7 +235,9 @@ puts("\t-S nn\t\tmysterious sort");
|
||||
puts("\t-L\t\tlist available filters");
|
||||
puts("\t-v\t\tincrease verbosity");
|
||||
|
||||
if (verbosity) { puts(""); fimg_print_version(2); puts(""); }
|
||||
if (verbosity) {
|
||||
list_crapulors("available filters");
|
||||
}
|
||||
|
||||
exit(0);
|
||||
}
|
||||
@ -256,11 +252,10 @@ int opt;
|
||||
int sort = 0;
|
||||
char *InFchain = "0";
|
||||
char *OutFchain = "0";
|
||||
char *out_dir = "p8/";
|
||||
|
||||
fprintf(stderr, "*** %s\n\tcompiled on %s %s\n", argv[0],
|
||||
fprintf(stderr, "*** %s : compiled by tTh, %s %s\n", __FILE__,
|
||||
__DATE__, __TIME__);
|
||||
if (verbosity) fimg_print_version(2);
|
||||
fimg_print_version(2);
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
/* this is for the debug off calling shellscript */
|
||||
@ -279,7 +274,6 @@ while ((opt = getopt(argc, argv, "E:F:hLnS:v")) != -1) {
|
||||
case 'S': sort = atoi(optarg); break;
|
||||
case 'v': verbosity++; break;
|
||||
case 'n': negative = 1; break;
|
||||
default: exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
@ -292,18 +286,6 @@ if (3 != (argc-optind)) {
|
||||
exit(1);
|
||||
}
|
||||
|
||||
out_dir = argv[optind+1];
|
||||
|
||||
/*
|
||||
* check for the export directory
|
||||
*/
|
||||
foo = check_if_export_dir_is_valid(out_dir, 0);
|
||||
if ( !foo ) {
|
||||
fprintf(stderr, "** export dir (%s) not valid\n", out_dir);
|
||||
fprintf(stderr, "** may be you have to create it ?\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
foo = parse_filter_chain(0, InFchain);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d parsing '%s'\n", foo, InFchain);
|
||||
@ -320,14 +302,13 @@ if (verbosity) {
|
||||
fprintf(stderr, "\toutput dir '%s'\n", argv[optind+1]);
|
||||
fprintf(stderr, "\tsrc filter '%s'\n", InFchain);
|
||||
fprintf(stderr, "\tout filter '%s'\n", OutFchain);
|
||||
fprintf(stderr, "\tsort %d\n", sort);
|
||||
}
|
||||
|
||||
if (verbosity > 1) {
|
||||
fputs("=========================\n", stderr);
|
||||
puts("=========================");
|
||||
filterstack_list(0, __FILE__);
|
||||
filterstack_list(1, __FILE__);
|
||||
fputs("=========================\n", stderr);
|
||||
puts("=========================");
|
||||
}
|
||||
|
||||
nbrsteps = atoi(argv[optind+2]);
|
||||
@ -4,8 +4,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
#include "metriques.h"
|
||||
|
||||
@ -86,9 +84,6 @@ for (idx=20; idx < size; idx+=42) {
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/*
|
||||
* LR mean left/right
|
||||
*/
|
||||
int get_float_metric_LR(FloatImg *pimg, float *where)
|
||||
{
|
||||
int coords[4], foo;
|
||||
@ -100,16 +95,8 @@ coords[2] = pimg->width / 2; // W
|
||||
coords[3] = pimg->height; // H
|
||||
|
||||
foo = stat_zone(pimg, coords, valL);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d stat zone in %s\n", foo, __func__);
|
||||
return foo;
|
||||
}
|
||||
coords[1] = pimg->width / 2;
|
||||
foo = stat_zone(pimg, coords, valR);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d stat zone in %s\n", foo, __func__);
|
||||
return foo;
|
||||
}
|
||||
|
||||
*where = valL[1] - valR[1];
|
||||
|
||||
@ -5,7 +5,6 @@
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <malloc.h>
|
||||
#include <math.h>
|
||||
@ -21,88 +20,6 @@
|
||||
*/
|
||||
extern int verbosity;
|
||||
|
||||
/* -------------------------------------------------------------- */
|
||||
/* new Sun Mar 31 22:31:31 UTC 2024 */
|
||||
|
||||
int add_a_border_0(FloatImg *src, FloatImg *dst)
|
||||
{
|
||||
|
||||
fprintf(stderr, "****** %s:%s to be implemented\n", __FILE__, __func__);
|
||||
|
||||
exit(1);
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/*
|
||||
* nouveau Sun Jul 16 07:37:22 UTC 2023
|
||||
*
|
||||
* may-be this can be an on-place function ?
|
||||
*
|
||||
*/
|
||||
int poke_sup_rb_g(FloatImg *src, FloatImg *dst)
|
||||
{
|
||||
int idx, nbpix, foo;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p )\n", __func__, src, dst);
|
||||
#endif
|
||||
|
||||
if ( (foo=fimg_images_not_compatible(src, dst)) )
|
||||
{
|
||||
fprintf(stderr, "%s: no compat %d\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
nbpix = src->width * src->height;
|
||||
if (verbosity > 1)
|
||||
fprintf(stderr, "%s work on %d pixels\n", __func__, nbpix);
|
||||
|
||||
for (idx=0; idx<nbpix; idx++) {
|
||||
dst->R[idx] = src->R[idx];
|
||||
dst->B[idx] = src->B[idx];
|
||||
if (src->R[idx] < src->B[idx])
|
||||
dst->G[idx] = src->R[idx];
|
||||
else
|
||||
dst->G[idx] = src->B[idx];
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/* nouveau 14 mai 2022 rue Ernest Renan */
|
||||
|
||||
int graylevel2popcolors(FloatImg *src, FloatImg *dst, int k)
|
||||
{
|
||||
int x, y;
|
||||
float rgb[3];
|
||||
float theoric_maxval, real_maxv;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, src, dst, k);
|
||||
#endif
|
||||
|
||||
theoric_maxval = src->fval * src->count;
|
||||
real_maxv = fimg_get_maxvalue(src);
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, "maxval: theoric= %.3f real= %.3f\n", \
|
||||
theoric_maxval, real_maxv);
|
||||
#endif
|
||||
|
||||
fimg_clear(dst);
|
||||
|
||||
for (y=0; y<src->height; y++) {
|
||||
|
||||
for (x=0; x<src->width; x++)
|
||||
{
|
||||
fimg_get_rgb(src, x, y, rgb);
|
||||
rgb[0] = real_maxv * fabs(cos(21.0 * rgb[0] / real_maxv));
|
||||
rgb[1] = real_maxv * fabs(cos(31.0 * rgb[1] / real_maxv));
|
||||
rgb[2] = real_maxv * fabs(cos(11.0 * rgb[2] / real_maxv));
|
||||
fimg_put_rgb(dst, x, y, rgb);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/*
|
||||
* please, add some parameters !
|
||||
@ -129,47 +46,21 @@ return -1;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/* nouveau du premier dimanche de 2020 'nextgen' */
|
||||
|
||||
/* CE TRUC NE MARCHE PAS COMME PRÉVU */
|
||||
|
||||
static int pixel_trinitron(FloatImg *pimg, int pos[4], float *fvals)
|
||||
{
|
||||
int x, y, pline, off;
|
||||
int ym;
|
||||
|
||||
// fprintf(stderr, ">>> %s ( %p %d,%d,%d,%d )\n", __func__, pimg,
|
||||
// pos[0], pos[1], pos[2], pos[3]);
|
||||
|
||||
fimg_clear_rectangle(pimg, pos);
|
||||
|
||||
ym = pos[1]+pos[3]-1;
|
||||
|
||||
#define FDIM 0.60
|
||||
|
||||
for (y=pos[1]; y<ym; y++) {
|
||||
for (y=pos[1]; y<pos[1]+pos[3]; y++) {
|
||||
pline = y*pimg->width;
|
||||
for (x=0; x<5; x++) {
|
||||
off = pline + (x+pos[0]);
|
||||
|
||||
/* wtf i'm doing here ? */
|
||||
if ( (pos[1]==y) || (ym-1==y) ) {
|
||||
pimg->R[off] = fvals[0] * FDIM;
|
||||
pimg->G[off+5] = fvals[1] * FDIM;
|
||||
pimg->B[off+10] = fvals[2] * FDIM;
|
||||
}
|
||||
else {
|
||||
for (x=pos[0]+2; x<pos[0]+pos[2]-2; x++) {
|
||||
off = pline + x;
|
||||
pimg->R[off] = fvals[0];
|
||||
pimg->G[off+5] = fvals[1];
|
||||
pimg->B[off+10] = fvals[2];
|
||||
}
|
||||
pimg->G[off] = fvals[1];
|
||||
pimg->B[off] = fvals[2];
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* need more explanation, need more work
|
||||
*/
|
||||
int trinitron(FloatImg *pimg, int notused)
|
||||
{
|
||||
int x, y, coo[4], foo;
|
||||
@ -179,36 +70,20 @@ float vals[3];
|
||||
fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, notused);
|
||||
#endif
|
||||
|
||||
/* XXX CRITICAL BUG XXX
|
||||
*
|
||||
* what to do if STP is not a modulo of
|
||||
* the width (or size) of the picture ?
|
||||
* why if img height is 600 and stp was 16 ?
|
||||
|
||||
tth@redlady:~/Devel/FloatImg/Fonderie$ bc -l
|
||||
600/16
|
||||
37.50000000000000000000
|
||||
|
||||
*
|
||||
* And this mistake is all around the code /o\
|
||||
*
|
||||
*/
|
||||
#define STP 15 /* stepd for x & y axex */
|
||||
#define STP 16 /* stepd for x & y axex */
|
||||
coo[2] = coo[3] = STP;
|
||||
|
||||
for (y=0; y < pimg->height-STP; y+=STP) {
|
||||
for (y=0; y<pimg->height; y+=STP) {
|
||||
coo[1] = y;
|
||||
for (x=0; x < pimg->width-STP; x+=STP) {
|
||||
for (x=0; x<pimg->width; x+=STP) {
|
||||
coo[0] = x;
|
||||
foo = stat_zone(pimg, coo, vals);
|
||||
if (foo) abort();
|
||||
/* next step : plot the datas */
|
||||
pixel_trinitron(pimg, coo, vals);
|
||||
}
|
||||
}
|
||||
#undef STP
|
||||
|
||||
// fprintf(stderr, " end trinitron\n"); // XXX
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
@ -436,40 +311,19 @@ return 0;
|
||||
/* -------------------------------------------------------------- */
|
||||
/* nouveau Mon 10 May 2021 08:46:02 PM CEST
|
||||
* chez Eric 1KA */
|
||||
int des_bords_sombres_b(FloatImg *pimg, int nbre)
|
||||
int des_bords_sombres_b(FloatImg *pimg, int offset)
|
||||
{
|
||||
int idx, x, foo;
|
||||
float coef, *fptr;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, nbre);
|
||||
fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pimg, offset);
|
||||
#endif
|
||||
|
||||
for (idx=0; idx<nbre; idx++) {
|
||||
|
||||
coef = (float)idx / (float)nbre;
|
||||
|
||||
fptr = pimg->R + (idx*pimg->width);
|
||||
for (x=0; x<pimg->width; x++) *fptr++ *= coef;
|
||||
fptr = pimg->G + (idx*pimg->width);
|
||||
for (x=0; x<pimg->width; x++) *fptr++ *= coef;
|
||||
fptr = pimg->B + (idx*pimg->width);
|
||||
for (x=0; x<pimg->width; x++) *fptr++ *= coef;
|
||||
|
||||
foo = (pimg->height-idx) - 1;
|
||||
fptr = pimg->R + (foo*pimg->width);
|
||||
// fprintf(stderr, "%5d %9.3f %p\n", foo, coef, fptr);
|
||||
for (x=0; x<pimg->width; x++) *fptr++ *= coef;
|
||||
fptr = pimg->G + (foo*pimg->width);
|
||||
for (x=0; x<pimg->width; x++) *fptr++ *= coef;
|
||||
fptr = pimg->B + (foo*pimg->width);
|
||||
for (x=0; x<pimg->width; x++) *fptr++ *= coef;
|
||||
|
||||
if (offset<0 || offset>=pimg->width) {
|
||||
fprintf(stderr, "%s: offset %d is bad\n", __func__, offset);
|
||||
return -66;
|
||||
}
|
||||
|
||||
// fprintf(stderr, "WARNING: %s badly implemented\n", __func__);
|
||||
|
||||
return 0;
|
||||
return -1;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/*
|
||||
@ -3,11 +3,8 @@
|
||||
* ---------------------------------------------------
|
||||
*/
|
||||
|
||||
int graylevel2popcolors(FloatImg *src, FloatImg *dst, int k);
|
||||
|
||||
int incrustation_vignette(FloatImg *src, FloatImg *dst, int k);
|
||||
|
||||
int poke_sup_rb_g(FloatImg *src, FloatImg *dst);
|
||||
|
||||
int trinitron(FloatImg *pimg, int notused);
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
/*
|
||||
SINGLE PICZ PROCESSOR
|
||||
|
||||
SINGLE
|
||||
experimental and/or testing code, do not use in
|
||||
production.
|
||||
|
||||
@ -9,8 +8,6 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
@ -26,7 +23,7 @@
|
||||
static int nextpng, counter;
|
||||
static char *destination;
|
||||
static int chainfilter;
|
||||
// static int outtype;
|
||||
static int outtype;
|
||||
|
||||
/* and the classic global var */
|
||||
extern int verbosity;
|
||||
@ -51,7 +48,7 @@ if (foo) {
|
||||
return -2;
|
||||
}
|
||||
if (S_IFDIR != (stbuf.st_mode & S_IFMT)) {
|
||||
fprintf(stderr, "%s: %s must be a directory\n", __func__, dest);
|
||||
fprintf(stderr, "! %s must be a directory\n", dest);
|
||||
return -3;
|
||||
}
|
||||
|
||||
@ -101,6 +98,7 @@ fprintf(stderr, "%s : %s\n", __FILE__, title);
|
||||
fprintf(stderr, " nextpng %d\n", nextpng);
|
||||
fprintf(stderr, " counter %d\n", counter);
|
||||
fprintf(stderr, " chainfilter %d\n", chainfilter);
|
||||
|
||||
fprintf(stderr, " destination %s\n", destination);
|
||||
|
||||
if (k) {
|
||||
@ -6,14 +6,12 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <unistd.h>
|
||||
#include <string.h>
|
||||
#include <glob.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
#include "utilfuncs.h"
|
||||
#include "crapulator.h"
|
||||
#include "filterstack.h"
|
||||
#include "single.h"
|
||||
@ -26,9 +24,6 @@
|
||||
int verbosity;
|
||||
|
||||
/* ----------------------------------------------------------- */
|
||||
/*
|
||||
* parameter 'duplic' is the repetition factor
|
||||
*/
|
||||
int run_the_singlepass(char *globber, char *destdir, int duplic,
|
||||
int fchain, int outfmt)
|
||||
{
|
||||
@ -39,11 +34,11 @@ char *fname;
|
||||
double elapsed;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( '%s' '%s' %d %d %d )\n", __func__,
|
||||
globber, destdir, duplic, fchain, outfmt);
|
||||
fprintf(stderr, ">>> %s ( '%s' '%s' %d %d )\n", __func__,
|
||||
globber, destdir, fchain, outfmt);
|
||||
#endif
|
||||
|
||||
if (verbosity) filterstack_list(fchain, "Run the single pass");
|
||||
// filterstack_list(fchain, "Run the single pass");
|
||||
|
||||
(void)fimg_timer_set(0);
|
||||
|
||||
@ -85,21 +80,17 @@ for (idx=0; idx<globbuf.gl_pathc; idx++) {
|
||||
else {
|
||||
foo = fimg_load_from_dump(fname, &image);
|
||||
}
|
||||
if (verbosity > 1) {
|
||||
fprintf(stderr, "%s: image '%s' loaded in %p\n",
|
||||
__func__, fname, &image);
|
||||
}
|
||||
if (foo) {
|
||||
fprintf(stderr, "get image -> %d\n", foo);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (0==idx && verbosity) {
|
||||
fprintf(stderr, "\tfirst image size %dx%d\n",
|
||||
if (0 == idx) {
|
||||
fprintf(stderr, "image size %dx%d\n",
|
||||
image.width, image.height);
|
||||
}
|
||||
|
||||
// fprintf(stderr, " %6ld %s\r", (long)globbuf.gl_pathc-idx, fname);
|
||||
fprintf(stderr, " %6ld %s\r", (long)globbuf.gl_pathc-idx, fname);
|
||||
|
||||
foo = filterstack_run(fchain, &image, 0);
|
||||
if (foo) {
|
||||
@ -115,6 +106,10 @@ for (idx=0; idx<globbuf.gl_pathc; idx++) {
|
||||
fprintf(stderr, "error %d on push_picture\n", foo);
|
||||
return foo;
|
||||
}
|
||||
if (loop) {
|
||||
/* this is just a wip XXX */
|
||||
microglitch(&image, loop);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -123,7 +118,7 @@ fprintf(stderr, "\n");
|
||||
globfree(&globbuf);
|
||||
|
||||
fimg_destroy(&image);
|
||||
// single_print_state("end of run", 0);
|
||||
single_print_state("end of run", 0);
|
||||
|
||||
elapsed = fimg_timer_get(0);
|
||||
fprintf(stderr, "%s: %ld frames, elapsed %.3f s, %.3f fps\n",
|
||||
@ -160,9 +155,9 @@ char *outdir = "./p8";
|
||||
int do_xper = 0;
|
||||
int repeat = 1;
|
||||
|
||||
fprintf(stderr, "*** %s\n\tcompiled %s %s\n", argv[0],
|
||||
fprintf(stderr, "*** %s : compiled %s %s\n", __FILE__,
|
||||
__DATE__, __TIME__);
|
||||
if (verbosity) fimg_print_version(2);
|
||||
fimg_print_version(2);
|
||||
|
||||
if (argc < 2) {
|
||||
fprintf(stderr, "\t/!\\ %s is option driven\n", argv[0]);
|
||||
@ -192,6 +187,7 @@ while ((opt = getopt(argc, argv, "hF:g:LO:r:svx")) != -1) {
|
||||
fprintf(stderr, "%s ABEND\n", argv[0]);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (repeat < 1) {
|
||||
@ -199,13 +195,6 @@ if (repeat < 1) {
|
||||
exit(2);
|
||||
}
|
||||
|
||||
foo = check_if_export_dir_is_valid(outdir, 0);
|
||||
if ( !foo ) {
|
||||
fprintf(stderr, "** export dir (%s) not valid\n", outdir);
|
||||
fprintf(stderr, "** may be you have to create it ?\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
foo = parse_filter_chain(FILTERS, filterchain);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d in parse_filter_chain\n", foo);
|
||||
@ -222,12 +211,9 @@ if (verbosity) {
|
||||
fprintf(stderr, "\tdo xper %d\n", do_xper);
|
||||
}
|
||||
|
||||
/*
|
||||
* REAL action here
|
||||
*/
|
||||
foo = run_the_singlepass(globbing, outdir, repeat,
|
||||
FILTERS, FILE_TYPE_PNG);
|
||||
fprintf(stderr, "\tRun the single pass --> %d\n", foo);
|
||||
fprintf(stderr, "\n\tRun the single pass --> %d\n", foo);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -4,7 +4,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <unistd.h>
|
||||
#include <string.h>
|
||||
#include <glob.h>
|
||||
@ -16,8 +15,6 @@
|
||||
#include "crapulator.h"
|
||||
#include "single.h"
|
||||
|
||||
#include "utilfuncs.h"
|
||||
|
||||
/* ----------------------------------------------------------- */
|
||||
|
||||
int verbosity;
|
||||
@ -30,30 +27,6 @@ int verbosity;
|
||||
|
||||
#define STK 6
|
||||
|
||||
/* ----------------------------------------------------------- */
|
||||
/* new Sat Nov 9 22:17:46 UTC 2024 */
|
||||
int essai_test_export_dir(char *footxt)
|
||||
{
|
||||
int foo;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( '%s' )\n", __func__, footxt);
|
||||
#endif
|
||||
|
||||
foo = check_if_export_dir_is_valid("/tmp/quux", 0);
|
||||
fprintf(stderr, " got %d\n\n", foo);
|
||||
|
||||
foo = check_if_export_dir_is_valid("/home", 0);
|
||||
fprintf(stderr, " got %d\n\n", foo);
|
||||
|
||||
foo = check_if_export_dir_is_valid("./", 0);
|
||||
fprintf(stderr, " got %d\n\n", foo);
|
||||
|
||||
foo = check_if_export_dir_is_valid("Makefile", 0);
|
||||
fprintf(stderr, " got %d\n\n", foo);
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* ----------------------------------------------------------- */
|
||||
|
||||
int essai_filterstack(char *fIname, char *fOname)
|
||||
@ -62,16 +35,11 @@ int foo;
|
||||
FloatImg image;
|
||||
double debut, fin;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( '%s' '%s' )\n", __func__, fIname, fOname);
|
||||
#endif
|
||||
|
||||
|
||||
// filterstack_list(STK, __func__);
|
||||
|
||||
foo = fimg_create_from_dump(fIname, &image);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d create from dump\n", __func__, foo);
|
||||
fprintf(stderr, "err %d create image\n", foo);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
@ -104,6 +72,8 @@ return 0;
|
||||
|
||||
foo = essayer_single("capture/???42.fimg", "/tmp/x8/", STK);
|
||||
fprintf(stderr, "essayer single -> %d\n", foo);
|
||||
|
||||
|
||||
*/
|
||||
int essayer_single(char *globpattern, char *destdir, int chain)
|
||||
{
|
||||
@ -190,24 +160,23 @@ puts("\t-s\tdo single test");
|
||||
exit(0);
|
||||
}
|
||||
/* ----------------------------------------------------------- */
|
||||
int experiment(char *fname)
|
||||
int experiment(void)
|
||||
{
|
||||
int foo;
|
||||
FloatImg image, dest;
|
||||
|
||||
fprintf(stderr, "----- EXPERIMENT on '%s' -----\n", fname);
|
||||
fprintf(stderr, "EXPERIMENT\n");
|
||||
|
||||
foo = fimg_create_from_dump(fname, &image);
|
||||
foo = fimg_create_from_dump("01137.fimg", &image);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d on create_from_dump\n",
|
||||
__func__, foo);
|
||||
fprintf(stderr, "%s: err %d on create\n", __func__, foo);
|
||||
return -1;
|
||||
}
|
||||
|
||||
foo = fimg_clone(&image, &dest, 0);
|
||||
foo = fimg_clone(&image, &dest, 1);
|
||||
foo = fimg_copy_data(&image, &dest);
|
||||
|
||||
foo = poke_sup_rb_g(&image, &dest);
|
||||
fprintf(stderr, "poke sup rb g --> %d\n", foo);
|
||||
incrustation_vignette(&image, &dest, 0);
|
||||
|
||||
fimg_export_picture(&dest, "foo.png", 0);
|
||||
|
||||
@ -249,25 +218,17 @@ while ((opt = getopt(argc, argv, "hF:g:i:Lo:O:svx")) != -1) {
|
||||
}
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s : argc=%d, optind=%d\n", argv[0], argc, optind);
|
||||
fprintf(stderr, "%s : argc = %d, optind = %d\n", argv[0], argc, optind);
|
||||
#endif
|
||||
|
||||
foo = essai_test_export_dir("bla bla");
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d in essai_test_export_dir\n", foo);
|
||||
exit(1);
|
||||
}
|
||||
exit(0);
|
||||
|
||||
foo = parse_filter_chain(STK, filterchain);
|
||||
if (foo) {
|
||||
fprintf(stderr, "err %d in parse_filter_chain\n", foo);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
||||
if (do_xper) {
|
||||
experiment(infile);
|
||||
experiment();
|
||||
return 0;
|
||||
}
|
||||
if (do_single) {
|
||||
@ -5,7 +5,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <unistd.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
@ -18,17 +17,14 @@ int verbosity;
|
||||
void fait_un_dessin(FloatImg *dessin)
|
||||
{
|
||||
|
||||
// fprintf(stderr, "je dessine dans %p\n", dessin);
|
||||
|
||||
fimg_draw_something(dessin);
|
||||
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
void help(void)
|
||||
void help(int k)
|
||||
{
|
||||
puts("Options :");
|
||||
puts("\t-d WxH\timage size");
|
||||
puts("\t-v\tincrease verbosity");
|
||||
exit(0);
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
@ -37,14 +33,14 @@ int main(int argc, char *argv[])
|
||||
{
|
||||
FloatImg fimgA, fimgB;
|
||||
int foo, opt;
|
||||
int W = 640, H = 480;
|
||||
int W = 800, H = 600;
|
||||
double tb;
|
||||
|
||||
while ((opt = getopt(argc, argv, "d:hv")) != -1) {
|
||||
switch(opt) {
|
||||
case 'd': parse_WxH(optarg, &W, &H);
|
||||
break;
|
||||
case 'h': help(); break;
|
||||
case 'h': help(0); break;
|
||||
case 'v': verbosity++; break;
|
||||
}
|
||||
}
|
||||
@ -60,7 +56,7 @@ fimg_drand48(&fimgB, 100.0);
|
||||
foo = fimg_dump_to_file(&fimgB, "B.fimg", 0);
|
||||
|
||||
fimg_timer_set(0);
|
||||
#define NBP 5
|
||||
#define NBP 500
|
||||
for (foo=0; foo<NBP; foo++) {
|
||||
if (verbosity) {
|
||||
printf("%5d / %5d\n", foo, NBP);
|
||||
@ -70,9 +66,9 @@ for (foo=0; foo<NBP; foo++) {
|
||||
// fimg_mul(&fimgA, &fimgB, &fimgA);
|
||||
}
|
||||
tb = fimg_timer_get(0);
|
||||
fprintf(stderr, "%s = %.2f seconds, %.2f s/p\n", __func__, tb, tb/(double)NBP);
|
||||
foo = fimg_save_as_pnm(&fimgA, "out.pnm", 0);
|
||||
foo = fimg_dump_to_file(&fimgA, "out.fimg", 0);
|
||||
fprintf(stderr, "%s = %f seconds\n", __func__, tb);
|
||||
foo = fimg_save_as_pnm(&fimgA, "drand48.pnm", 0);
|
||||
foo = fimg_dump_to_file(&fimgA, "drand48.fimg", 0);
|
||||
|
||||
fimg_destroy(&fimgA);
|
||||
fimg_destroy(&fimgB);
|
||||
15
extras/experiment/Makefile
Normal file
15
extras/experiment/Makefile
Normal file
@ -0,0 +1,15 @@
|
||||
|
||||
# experiments
|
||||
|
||||
|
||||
COPT = -Wall -fpic -g -DDEBUG_LEVEL=1 -lm
|
||||
DEPS = ../floatimg.h ../libfloatimg.a Makefile
|
||||
LIBS = -ltiff -lpnglite -lcfitsio
|
||||
|
||||
all: assemblage extracteur
|
||||
|
||||
assemblage: assemblage.c ${DEPS}
|
||||
gcc $(COPT) $< ../libfloatimg.a $(LIBS) -o $@
|
||||
|
||||
extracteur: extracteur.c ${DEPS}
|
||||
gcc $(COPT) $< ../libfloatimg.a $(LIBS) -o $@
|
||||
6
extras/experiment/README.md
Normal file
6
extras/experiment/README.md
Normal file
@ -0,0 +1,6 @@
|
||||
# EXPÉRIMENTATION ÀLC
|
||||
|
||||
## ASSEMBLAGE
|
||||
|
||||
## EXTRACTEUR
|
||||
|
||||
@ -4,7 +4,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
@ -51,6 +50,7 @@ if (foo) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
foo = fimg_export_picture(&grande, outname, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: error %d export '%s'\n", __func__,
|
||||
131
extras/experiment/extracteur.c
Normal file
131
extras/experiment/extracteur.c
Normal file
@ -0,0 +1,131 @@
|
||||
/*
|
||||
* another ugly experiment
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
// #include "incrustator.h"
|
||||
|
||||
int verbosity;
|
||||
|
||||
/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
|
||||
|
||||
/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
|
||||
int essai_extraction(FloatImg *in, FloatImg *out, FimgArea51 *rect)
|
||||
{
|
||||
int foo;
|
||||
int xs, ys, xd, yd;
|
||||
int count;
|
||||
float rgb[3];
|
||||
|
||||
if (verbosity) {
|
||||
fimg_describe(in, "source");
|
||||
fimg_describe(out, "destination");
|
||||
print_rectangle(__func__, rect);
|
||||
}
|
||||
|
||||
count = 0;
|
||||
for (yd=0; yd<rect->h; yd++) {
|
||||
ys = yd + rect->y;
|
||||
if ((ys<0) || (ys>=in->height)) continue;
|
||||
for (xd=0; xd<rect->w; xd++) {
|
||||
xs = xd + rect->x;
|
||||
if ((xs<0) || (xs>=in->width)) continue;
|
||||
fimg_get_rgb(in, xs, ys, rgb);
|
||||
fimg_put_rgb(out, xd, yd, rgb);
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
// fprintf(stderr, "%s: %d pix moved\n", __func__, count);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
|
||||
void help(int k)
|
||||
{
|
||||
puts("Usage:\n\textracteur in.fimg w,h,x,y out.???");
|
||||
}
|
||||
/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int foo, opt;
|
||||
FloatImg src, dst;
|
||||
FimgArea51 zone;
|
||||
char *infile = "foo.fimg";
|
||||
char *outfile = "out.fimg";
|
||||
|
||||
verbosity = 0;
|
||||
|
||||
#if 0
|
||||
for (foo=0; foo<argc; foo++) {
|
||||
fprintf(stderr, "%9d %s\n", foo, argv[foo]);
|
||||
}
|
||||
#endif
|
||||
|
||||
while ((opt = getopt(argc, argv, "hv")) != -1) {
|
||||
switch(opt) {
|
||||
case 'h': help(0), exit(0); break;
|
||||
case 'v': verbosity++; break;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
if (3 != argc-optind) {
|
||||
fprintf(stderr, "---- %s errcli c=%d %d ----\n", argv[0],
|
||||
argc, argc-optind);
|
||||
help(1);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (verbosity) {
|
||||
fprintf(stderr, "*** %s %s %s\n", argv[0], __DATE__, __TIME__);
|
||||
fimg_print_version(1);
|
||||
}
|
||||
|
||||
infile = argv[optind]; outfile = argv[optind+2];
|
||||
fprintf(stderr, "%s %s -> %s\n", argv[0], infile, outfile);
|
||||
|
||||
foo = fimg_create_from_dump(infile, &src);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d loading image '%s'\n", __func__,
|
||||
foo, infile);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (4 != parse_rectangle( argv[optind+1], &zone, 0) ) {
|
||||
fprintf(stderr, "%s: error in parsing of '%s'\n",
|
||||
argv[0], argv[optind+1]);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// zone.w = src.width / 2; zone.h = src.height / 2;
|
||||
// zone.x = src.width / 4 ; zone.y = src.height / 4;
|
||||
|
||||
if (verbosity) print_rectangle(argv[0], &zone);
|
||||
|
||||
foo = fimg_create(&dst, zone.w, zone.h, FIMG_TYPE_RGB);
|
||||
if (foo) {
|
||||
fprintf(stderr, "NO PICZ EPIC FAIL %d\n", foo);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
foo = fimg_extractor(&src, &dst, &zone);
|
||||
if (foo) {
|
||||
fprintf(stderr, "EXTRACTOR EPIC FAIL %d\n", foo);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
foo = fimg_export_picture(&dst, outfile, 0);
|
||||
if (foo) {
|
||||
fprintf(stderr, "export '%s' -> err %d\n", outfile, foo);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ---------------------------------------------- ~~~~~~~~~~~~~~~~ */
|
||||
10
funcs/.gitignore
vendored
10
funcs/.gitignore
vendored
@ -1,10 +0,0 @@
|
||||
|
||||
tpnm
|
||||
t
|
||||
*.o
|
||||
*.png
|
||||
*.gif
|
||||
*.fits
|
||||
*.tiff
|
||||
|
||||
|
||||
@ -1,53 +0,0 @@
|
||||
# Fonctions
|
||||
|
||||
Plein de fonctions qu'il serait bon de documenter :)
|
||||
|
||||
|
||||
## Contours
|
||||
|
||||
Détecter des contours est une activité respectable. Mais difficile.
|
||||
Une recherche dans la littérature s'impose.
|
||||
|
||||
## Exporter
|
||||
|
||||
`fimg_exporter` est une méta-fonction qui va sauvegarder (dans la mesure de ses conséquences)
|
||||
une image en fonction de l'extension du nom de fichier fourni.
|
||||
|
||||
### PNG
|
||||
|
||||
__Attention__ : la bibliothèque `pnglite` actuellement utilisée pour lire
|
||||
les fichiers PNG n'accepte que certains types de fichiers.
|
||||
Et en particulier, elle brotche sur ceux produits par ImageMagick !
|
||||
|
||||
### FITS
|
||||
|
||||
Ce [format de fichier](https://heasarc.gsfc.nasa.gov/docs/software/fitsio/c/c_user/node1.html)
|
||||
est utilisé en astronomie.
|
||||
Son support est actuellement minimaliste.
|
||||
|
||||
|
||||
### DICOM
|
||||
|
||||
https://en.wikipedia.org/wiki/DICOM et ça semble bien compliqué,
|
||||
donc ça reste pour le moment au stade de vague projet :(
|
||||
|
||||
## Sfx
|
||||
|
||||
Effets spéciaux divers. Ils sont répartis dans plusieurs fichiers
|
||||
(`sfx[0-4].c`) sans raison de classement apparente.
|
||||
|
||||
Certains peuvent être directement utilisés
|
||||
avec l'outil [../tools/fimgfx.c](fimgfx).
|
||||
Leur paramétrage est trop sommaire.
|
||||
|
||||
La fonction `fimg_pixelize_h_rnd` est issue d'une idée qui m'est venue
|
||||
dans la roulotte de TerreBlanque. Elle a besoin de recherches sur la
|
||||
dynamique temporelle, et d'une FSM à trois états.
|
||||
|
||||
## Dithering
|
||||
|
||||
Work in progress...
|
||||
|
||||
Une difficulté dans ce domaine, c'est la *floattitude* des pixels,
|
||||
sur laquelle il est difficile d'appliquer des operations binaires,
|
||||
comme le XOR.
|
||||
@ -1,157 +0,0 @@
|
||||
/*
|
||||
* DECOMPOSITION RGB
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* == ---------------------------------------------------- == */
|
||||
|
||||
/* some dirty macros */
|
||||
|
||||
#define pixidx(fi,x,y) (((y)*fi->width)+(x))
|
||||
|
||||
#define getRpix(fi,x,y) (fi->R[ pixidx(fi,(x),(y)) ])
|
||||
#define getGpix(fi,x,y) (fi->G[ pixidx(fi,(x),(y)) ])
|
||||
#define getBpix(fi,x,y) (fi->B[ pixidx(fi,(x),(y)) ])
|
||||
|
||||
/* A lot of strange and usefull parenthesis */
|
||||
|
||||
/* == ---------------------------------------------------- == */
|
||||
#if DEBUG_LEVEL
|
||||
static float compute_z_value(float r, float g, float b)
|
||||
{
|
||||
double dval;
|
||||
|
||||
return 42.0;
|
||||
}
|
||||
#endif
|
||||
/* == ---------------------------------------------------- == */
|
||||
|
||||
int fimg_decomp_rgbz_color(FloatImg *psrc, FloatImg *pdst, int k)
|
||||
{
|
||||
int x, y, x2, y2;
|
||||
int w2, h2;
|
||||
float cumul, vgray;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__,
|
||||
psrc, pdst, k);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* XXX useless message ?
|
||||
*/
|
||||
if (k) { fprintf(stderr, "k=%d in %s\n", k, __func__); }
|
||||
|
||||
fimg_clear(pdst);
|
||||
w2 = psrc->width/2; h2 = psrc->height/2;
|
||||
|
||||
for (y=0; y<h2; y++)
|
||||
{
|
||||
y2 = y * 2;
|
||||
for (x=0; x<w2; x++) {
|
||||
x2 = x * 2;
|
||||
|
||||
cumul = getRpix(psrc, x2, y2) +
|
||||
getRpix(psrc, x2, y2+1) +
|
||||
getRpix(psrc, x2+1, y2) +
|
||||
getRpix(psrc, x2+1, y2+1);
|
||||
cumul /= 4, vgray = cumul;
|
||||
pdst->R[pixidx(pdst,x,y)] = cumul;
|
||||
pdst->R[pixidx(pdst,x+w2,y+h2)] = cumul;
|
||||
|
||||
cumul = getGpix(psrc, x2, y2) +
|
||||
getGpix(psrc, x2, y2+1) +
|
||||
getGpix(psrc, x2+1, y2) +
|
||||
getGpix(psrc, x2+1, y2+1);
|
||||
cumul /= 4, vgray += cumul;
|
||||
pdst->G[pixidx(pdst,x+w2,y)] = cumul;
|
||||
pdst->G[pixidx(pdst,x+w2,y+h2)] = cumul;
|
||||
|
||||
cumul = getBpix(psrc, x2, y2) +
|
||||
getBpix(psrc, x2, y2+1) +
|
||||
getBpix(psrc, x2+1, y2) +
|
||||
getBpix(psrc, x2+1, y2+1);
|
||||
cumul /= 4, vgray += cumul;
|
||||
pdst->B[pixidx(pdst,x,y+h2)] = cumul;
|
||||
pdst->B[pixidx(pdst,x+w2,y+h2)] = cumul;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* == ---------------------------------------------------- == */
|
||||
|
||||
/* PUTAIN LE COPIER/COLLÉ DE BATARD !!! */
|
||||
|
||||
int fimg_decomp_rgbz_gray(FloatImg *psrc, FloatImg *pdst, int k)
|
||||
{
|
||||
int x, y, x2, y2;
|
||||
int w2, h2, idx;
|
||||
float cumul, vgray;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__,
|
||||
psrc, pdst, k);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* XXX useless message ?
|
||||
*/
|
||||
if (k) { fprintf(stderr, "k=%d in %s\n", k, __func__); }
|
||||
|
||||
fimg_clear(pdst);
|
||||
w2 = psrc->width/2; h2 = psrc->height/2;
|
||||
|
||||
for (y=0; y<h2; y++)
|
||||
{
|
||||
y2 = y * 2;
|
||||
for (x=0; x<w2; x++) {
|
||||
x2 = x * 2;
|
||||
|
||||
cumul = getRpix(psrc, x2, y2) +
|
||||
getRpix(psrc, x2, y2+1) +
|
||||
getRpix(psrc, x2+1, y2) +
|
||||
getRpix(psrc, x2+1, y2+1);
|
||||
cumul /= 4, vgray = cumul;
|
||||
idx = pixidx(pdst,x,y);
|
||||
pdst->R[idx] = pdst->G[idx] = pdst->B[idx] = cumul;
|
||||
|
||||
cumul = getGpix(psrc, x2, y2) +
|
||||
getGpix(psrc, x2, y2+1) +
|
||||
getGpix(psrc, x2+1, y2) +
|
||||
getGpix(psrc, x2+1, y2+1);
|
||||
cumul /= 4, vgray += cumul;
|
||||
idx = pixidx(pdst,x+w2,y);
|
||||
pdst->R[idx] = pdst->G[idx] = pdst->B[idx] = cumul;
|
||||
|
||||
cumul = getBpix(psrc, x2, y2) +
|
||||
getBpix(psrc, x2, y2+1) +
|
||||
getBpix(psrc, x2+1, y2) +
|
||||
getBpix(psrc, x2+1, y2+1);
|
||||
cumul /= 4, vgray += cumul;
|
||||
idx = pixidx(pdst,x,y+h2);
|
||||
pdst->R[idx] = pdst->G[idx] = pdst->B[idx] = cumul;
|
||||
|
||||
idx = pixidx(pdst,x+w2,y+h2);
|
||||
pdst->R[idx] = pdst->G[idx] = \
|
||||
pdst->B[idx] = vgray / 3.0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* == ---------------------------------------------------- == */
|
||||
@ -1,83 +0,0 @@
|
||||
/*
|
||||
* FloatImg library from tTh - really ugly code inside
|
||||
*
|
||||
* F A L S E C O L O R S
|
||||
* or fake colors ?
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/time.h>
|
||||
#include <math.h>
|
||||
#include "../floatimg.h"
|
||||
|
||||
/* -------------------------------------------------------------- */
|
||||
/* this is a global vars exported from main */
|
||||
extern int verbosity;
|
||||
|
||||
/* -------------------------------------------------------------- */
|
||||
/* TRUCS A VOIR
|
||||
|
||||
f(x,y) = (((y & x) * (y - x)) % ((21 & x) * (y | 8))) ^ (~((x & 7) | (x % x)))
|
||||
|
||||
|
||||
*/
|
||||
/* -------------------------------------------------------------- */
|
||||
/* nouveau 18 mai 2022 */
|
||||
/* please explain the meaning of 'valf' parameter */
|
||||
int fimg_falsecolors_0(FloatImg *src, FloatImg *dst, int k, float valf)
|
||||
{
|
||||
int x, y, offset;
|
||||
float r, g, b, gray, maxv;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d %f )\n", __func__,
|
||||
src, dst, k, valf);
|
||||
#endif
|
||||
|
||||
if (k) {
|
||||
fprintf(stderr, "%s : %d %f\n", __func__, k, valf);
|
||||
}
|
||||
|
||||
/* check validity of parameters */
|
||||
if (FIMG_TYPE_RGB != dst->type) {
|
||||
fprintf(stderr, "in %s, picz at %p is not valid\n",
|
||||
__func__, dst);
|
||||
abort();
|
||||
/* BLAM! */
|
||||
}
|
||||
|
||||
|
||||
maxv = fimg_get_plane_maxvalue(src, 'r');
|
||||
fprintf(stderr, "%s: maxv of red plane = %f\n", __func__, maxv);
|
||||
|
||||
/* enter big loop */
|
||||
offset = 0;
|
||||
for (y=0; y<src->height; y++) {
|
||||
for (x=0; x<src->width; x++) {
|
||||
|
||||
gray = src->R[offset];
|
||||
|
||||
if (gray < maxv/2.0) {
|
||||
r = gray * 2.0;
|
||||
g = 0.0;
|
||||
}
|
||||
else {
|
||||
r = 0.0;
|
||||
g = gray * 2.0;
|
||||
}
|
||||
b = fmodf(gray*8.0, maxv);
|
||||
|
||||
dst->R[offset] = r;
|
||||
dst->G[offset] = g;
|
||||
dst->B[offset] = b;
|
||||
|
||||
/* and GOTO next pixel */
|
||||
offset++;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
@ -1,33 +0,0 @@
|
||||
/*
|
||||
Digital Imaging and Communications in Medicine
|
||||
|
||||
nouveau Fri 26 Nov 2021 11:12:44 PM CET - allée de Dinan
|
||||
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity; /* must be declared around main() */
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_save_plane_as_dicom(FloatImg *src, char *outname,
|
||||
char plane, int flags)
|
||||
{
|
||||
float *planeptr;
|
||||
|
||||
fprintf(stderr, ">>> %s ( %p %s %c %d )\n", __func__, src, outname, plane, flags);
|
||||
|
||||
planeptr = charplane2int(plane, src); /* please explain XXX */
|
||||
fprintf(stderr, "planeptr is %p\n", planeptr);
|
||||
|
||||
if (verbosity) {
|
||||
fimg_describe(src, outname);
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
@ -1,89 +0,0 @@
|
||||
/*
|
||||
* FLOATIMG
|
||||
* --------
|
||||
|
||||
* F M O R P H O
|
||||
*
|
||||
* nouveau 30 septembre 2022 / integration 28 octobre 2022
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
/* --------------------------------------------------------------------- !*/
|
||||
static struct
|
||||
{
|
||||
int x, y;
|
||||
} deltas[] =
|
||||
{ { -1, -1, },
|
||||
{ 0, -1, },
|
||||
{ 1, -1, },
|
||||
{ -1, 0, },
|
||||
{ 0, 0, },
|
||||
{ 1, 0, },
|
||||
{ -1, 1, },
|
||||
{ 0, 1, },
|
||||
{ 1, 1 }
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int x, y; // not used
|
||||
float r, g, b;
|
||||
float fgris;
|
||||
int rang;
|
||||
} fpixel;
|
||||
|
||||
static fpixel pixels[9];
|
||||
|
||||
/* --------------------------------------------------------------------- !*/
|
||||
static int comparaison_fgris(const void *A, const void *B)
|
||||
{
|
||||
return ((fpixel *)A)->fgris > ((fpixel *)B)->fgris;
|
||||
}
|
||||
/* --------------------------------------------------------------------- !*/
|
||||
/*
|
||||
* this is a klugy approch, sorry.
|
||||
*/
|
||||
int fimg_filtre_morpho_0(FloatImg *sfimg, FloatImg *dfimg, int index)
|
||||
{
|
||||
int xs, ys, loop9;
|
||||
int xp, yp;
|
||||
float rgb[3];
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, sfimg, dfimg, index);
|
||||
#endif
|
||||
|
||||
if ( (index<0) || (index>8)) {
|
||||
fprintf(stderr, " %s: bad index %d\n", __func__, index);
|
||||
#if MUST_ABORT
|
||||
fflush(stderr); abort();
|
||||
#endif
|
||||
return -1;
|
||||
}
|
||||
|
||||
fimg_clear(dfimg);
|
||||
|
||||
for (ys=1; ys<sfimg->height-1; ys++) {
|
||||
for (xs=1; xs<sfimg->width-1; xs++) {
|
||||
for (loop9=0; loop9<9; loop9++) {
|
||||
xp = xs + deltas[loop9].x;
|
||||
yp = ys + deltas[loop9].y;
|
||||
fimg_get_rgb(sfimg, xp, yp, rgb);
|
||||
pixels[loop9].fgris = rgb[0] + rgb[1] + rgb[2];
|
||||
pixels[loop9].rang = loop9;
|
||||
}
|
||||
qsort(&pixels, 9, sizeof(fpixel), comparaison_fgris);
|
||||
rgb[0] = rgb[1] = rgb[2] = pixels[index].fgris;
|
||||
fimg_put_rgb(dfimg, xs, ys, rgb);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- !*/
|
||||
@ -1,45 +0,0 @@
|
||||
/*
|
||||
* KILL RGB !
|
||||
*
|
||||
* nouveau TerreBlanque 4 octobre 2021
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
#include "tests.h"
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
int fimg_killrgb_v(FloatImg *src, FloatImg *dst, int k)
|
||||
{
|
||||
int line, col;
|
||||
int ir;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, src, dst, k);
|
||||
#endif
|
||||
|
||||
if (k) { fprintf(stderr, "in %s k was %d\n", __func__, k); }
|
||||
|
||||
fimg_clear(dst);
|
||||
ir = 0;
|
||||
|
||||
for (line=0; line<src->height; line++) {
|
||||
// fprintf(stderr, "%s line %d\n", __func__, line);
|
||||
for (col=0; col<(src->width-3); col+=3) {
|
||||
|
||||
dst->R[ir ] = src->R[ir]; ir++;
|
||||
dst->G[ir+1] = src->G[ir]; ir++;
|
||||
dst->B[ir+2] = src->B[ir]; ir++;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
101
funcs/pixelize.c
101
funcs/pixelize.c
@ -1,101 +0,0 @@
|
||||
/*
|
||||
* P I X E L I Z E
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* -------------------------------------------------------------- */
|
||||
/* nouveau 10 octobre 2021 dans la roulotte de Terreblanque */
|
||||
|
||||
#define LARGEUR 16
|
||||
|
||||
int fimg_pixelize_h_0(FloatImg *psrc, FloatImg *pdst, int largeur)
|
||||
{
|
||||
int line, col, loop, idx;
|
||||
float cr, cg, cb; /* cumuls */
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, psrc, pdst, largeur);
|
||||
#endif
|
||||
|
||||
if (fimg_images_not_compatible(psrc, pdst)) {
|
||||
fprintf(stderr, "%s: err compatibility\n", __func__);
|
||||
return -8;
|
||||
}
|
||||
|
||||
switch(largeur) {
|
||||
case 8: case 16: case 32:
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "%s: bad width %d\n", __func__, largeur);
|
||||
return -77;
|
||||
}
|
||||
|
||||
for (line=0; line<psrc->height; line++) {
|
||||
for (col=0; col<psrc->width; col+=largeur) {
|
||||
cr = cg = cb = 0.0;
|
||||
idx = line * psrc->width + col;
|
||||
for (loop=0; loop<largeur; loop++) {
|
||||
cr += psrc->R[idx+loop];
|
||||
cg += psrc->G[idx+loop];
|
||||
cb += psrc->B[idx+loop];
|
||||
}
|
||||
for (loop=0; loop<largeur; loop++) {
|
||||
pdst->R[idx+loop] = cr / (float)largeur;
|
||||
pdst->G[idx+loop] = cg / (float)largeur;
|
||||
pdst->B[idx+loop] = cb / (float)largeur;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/*
|
||||
* un essai dans la roulotte :)
|
||||
* 11 oct 2021 : premier jet, essai concluant, mais necessite
|
||||
* du travail sur les rand() pour etre plus 'noisy'
|
||||
*
|
||||
*/
|
||||
int fimg_pixelize_h_rnd(FloatImg *psrc, FloatImg *pdst, int largeur)
|
||||
{
|
||||
static int count = 0;
|
||||
static int flag = 0;
|
||||
int foo;
|
||||
|
||||
/* may be a mollyguard on 'largeur' parameter ? */
|
||||
|
||||
if (0==count) {
|
||||
if (flag) {
|
||||
count = irand2(5, 10);
|
||||
flag = ! flag;
|
||||
}
|
||||
else {
|
||||
count = irand2(20, 40);
|
||||
flag = ! flag;
|
||||
}
|
||||
if (verbosity) {
|
||||
fprintf(stderr, "%s c=%d f=%c\n", __func__,
|
||||
count, flag?'T':'F');
|
||||
}
|
||||
}
|
||||
|
||||
if (verbosity) {
|
||||
fprintf(stderr, "%s: count=%d flag=%d\n", __func__, count, flag);
|
||||
}
|
||||
|
||||
foo = fimg_pixelize_h_0(psrc, pdst, flag ? largeur : 32);
|
||||
if (foo) {
|
||||
fprintf(stderr, "pixelize_h_0 give err %d in %s\n", foo, __func__);
|
||||
}
|
||||
|
||||
count--; /* nice trick bro */
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
@ -1,38 +0,0 @@
|
||||
/*
|
||||
* R E C T A N G L E
|
||||
* This is an eternal WIP, sorry...
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
int fimg_clear_rectangle(FloatImg *pi, int coo[4])
|
||||
{
|
||||
int line, off;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p )\n", __func__, pi, coo);
|
||||
#endif
|
||||
|
||||
/* please add boudary checks */
|
||||
|
||||
for (line=0; line<coo[3]; line++) {
|
||||
off = (line+coo[1])*pi->width + coo[0];
|
||||
// fprintf(stderr, "line %3d off %8d\n", line, off);
|
||||
/* Kaboum ! */
|
||||
memset(pi->R + off, 0, coo[2]*sizeof(float));
|
||||
memset(pi->G + off, 0, coo[2]*sizeof(float));
|
||||
memset(pi->B + off, 0, coo[2]*sizeof(float));
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
99
funcs/sfx3.c
99
funcs/sfx3.c
@ -1,99 +0,0 @@
|
||||
/*
|
||||
* FLOATIMG - a kluge from tTh
|
||||
* ---------------------------
|
||||
*
|
||||
* some strange effects on floating pictures, made in
|
||||
* the batcave of "Le Bib", in Montpellier.
|
||||
*/
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* -------------------------------------------------------------- */
|
||||
/* new Sun 29 Jan 2023 10:01:39 PM CET
|
||||
|
||||
*/
|
||||
int fimg_make_rndfluffy_lines(FloatImg *src, FloatImg *dst, int rndt)
|
||||
{
|
||||
int x, y, ol;
|
||||
float accu;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( '%p' '%p' %d )\n", __func__,
|
||||
src, dst, rndt);
|
||||
#endif
|
||||
|
||||
if (fimg_images_not_compatible(src, dst)) {
|
||||
/* be hard for the lamers */
|
||||
fprintf(stderr, "compatibility OUPS in %s\n", __func__);
|
||||
abort();
|
||||
}
|
||||
|
||||
for (y=0; y<src->height; y++) {
|
||||
ol = y * src->width;
|
||||
if (rndt < (rand() % 100)) {
|
||||
accu = 0.0;
|
||||
for (x=0; x<src->width; x++) accu += src->R[ol + x];
|
||||
accu /= (float)src->width;
|
||||
for (x=0; x<src->width; x++) dst->R[ol + x] = accu;
|
||||
}
|
||||
else {
|
||||
for (x=0; x<src->width; x++) {
|
||||
dst->R[ol+x] = src->R[ol+x];
|
||||
dst->G[ol+x] = src->G[ol+x];
|
||||
dst->B[ol+x] = src->B[ol+x];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
int fimg_crump_hard(FloatImg *src, FloatImg *dst, float kval, int notused)
|
||||
{
|
||||
float halfval;
|
||||
float rgb[3];
|
||||
int x, y, foo;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %f 0x%04x )\n", __func__,
|
||||
src, dst, kval, notused);
|
||||
#endif
|
||||
|
||||
if (notused) {
|
||||
fprintf(stderr, "%s: notused was %d, must be 0\n",
|
||||
__func__, notused);
|
||||
}
|
||||
|
||||
halfval = fimg_get_maxvalue(src) / 2.0;
|
||||
if (verbosity > 1) {
|
||||
fprintf(stderr, "%s: kval=%f & halfval=%f\n", __func__,
|
||||
kval, halfval);
|
||||
}
|
||||
|
||||
for (y=0; y<src->height; y++) {
|
||||
for (x=0; x<src->width; x++) {
|
||||
foo = fimg_get_rgb(src, x, y, rgb);
|
||||
if (foo) return foo;
|
||||
|
||||
if (rgb[0] > halfval) rgb[0] /= 2.0;
|
||||
if (rgb[1] > halfval) rgb[1] /= 2.0;
|
||||
if (rgb[2] > halfval) rgb[2] /= 2.0;
|
||||
|
||||
foo = fimg_put_rgb(dst, x, y, rgb);
|
||||
if (foo) return foo;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
|
||||
120
funcs/sfx4.c
120
funcs/sfx4.c
@ -1,120 +0,0 @@
|
||||
/*
|
||||
* FLOATIMG - a kluge from tTh
|
||||
* ---------------------------
|
||||
*
|
||||
* some strange effects on floating pictures.
|
||||
*/
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* -------------------------------------------------------------- */
|
||||
int fimg_sfx_triplemul(FloatImg *src, FloatImg *dst, int notused)
|
||||
{
|
||||
int x, y, foo;
|
||||
float in[3], out[3];
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p 0x%04x )\n", __func__, src, dst, notused);
|
||||
#endif
|
||||
|
||||
if (notused) {
|
||||
fprintf(stderr, "notused was %d, must be 0 in %s\n",
|
||||
notused, __func__);
|
||||
}
|
||||
|
||||
for (y=0; y<src->height; y++) {
|
||||
for (x=0; x<src->width; x++) {
|
||||
foo = fimg_get_rgb(src, x, y, in);
|
||||
if (foo) return foo;
|
||||
out[0] = in[1] * in[2];
|
||||
out[1] = in[0] * in[2];
|
||||
out[2] = in[0] * in[1];
|
||||
// fprintf(stderr, "%9f %9f %9f\n", out[0], out[1], out[2]);
|
||||
foo = fimg_put_rgb(dst, x, y, out);
|
||||
if (foo) return foo;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
/*
|
||||
* see also:
|
||||
sfx3.c:fimg_crump_hard()
|
||||
*/
|
||||
int fimg_split_level(FloatImg *src, FloatImg *dst, int notused)
|
||||
{
|
||||
float means[4];
|
||||
// float in[3];
|
||||
int foo, idx, surface;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p 0x%04x )\n", __func__, src, dst, notused);
|
||||
#endif
|
||||
|
||||
if (notused) {
|
||||
fprintf(stderr, "notused was %d, must be 0 in %s\n",
|
||||
notused, __func__);
|
||||
}
|
||||
|
||||
foo = fimg_meanvalues(src, means);
|
||||
if (foo) {
|
||||
return -66;
|
||||
}
|
||||
|
||||
surface = src->width*src->height;
|
||||
for(idx=0; idx<surface; idx++) {
|
||||
if (src->R[idx]<means[0]) dst->R[idx]=src->R[idx]*2.0;
|
||||
else dst->R[idx]=(src->R[idx]-means[0])*2.0;
|
||||
if (src->G[idx]<means[1]) dst->G[idx]=src->G[idx]*2.0;
|
||||
else dst->G[idx]=(src->G[idx]-means[1])*2.0;
|
||||
if (src->B[idx]<means[2]) dst->B[idx]=src->B[idx]*2.0;
|
||||
else dst->B[idx]=(src->B[idx]-means[2])*2.0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
int fimg_make_triptyq(FloatImg *src, FloatImg *dst, int notused)
|
||||
{
|
||||
int x, y, sh, foo, ow;
|
||||
float r, g, b, in[3];
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p 0x%04x )\n", __func__, src, dst, notused);
|
||||
#endif
|
||||
|
||||
if (fimg_images_not_compatible(src, dst)) {
|
||||
fprintf(stderr, "%s : compatibility error\n", __func__);
|
||||
return -8;
|
||||
}
|
||||
|
||||
fimg_clear(dst);
|
||||
|
||||
ow = src->width / 3;
|
||||
for (y=0; y<src->height; y++) {
|
||||
for (x=0; x<src->width/3; x++) {
|
||||
r = g = b = 0.0;
|
||||
for (sh=0; sh<3; sh++) {
|
||||
foo = fimg_get_rgb(src, (x*3)+sh, y, in);
|
||||
r+=in[0], g+=in[1], b+=in[2];
|
||||
}
|
||||
for (sh=0; sh<3; sh++) {
|
||||
fimg_plot_rgb(dst, x, y, r, 0, 0);
|
||||
fimg_plot_rgb(dst, x+ow, y, 0, g, 0);
|
||||
fimg_plot_rgb(dst, x+(2*ow), y, 0, 0, b);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------- */
|
||||
@ -1,67 +0,0 @@
|
||||
/*
|
||||
* FLOATIMG
|
||||
* fabriquer une pseudo-image thermique
|
||||
*
|
||||
* new: Wed Mar 20 16:55:09 UTC 2024 dans ma maison du Gers
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
* parameter k in not used, but may be in the futur.
|
||||
*/
|
||||
int fimg_auto_thermique(FloatImg *src, FloatImg *dst, int k)
|
||||
{
|
||||
// int x, y, off;
|
||||
int idx, surface;
|
||||
|
||||
float seuil, gray;
|
||||
double graymean;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p %d )\n", __func__, src, dst, k);
|
||||
#endif
|
||||
|
||||
if (0!=k) {
|
||||
fprintf(stderr, "%s: k must be 0, was %d\n", __func__, k);
|
||||
}
|
||||
|
||||
surface = src->width * src->height;
|
||||
// fprintf(stderr, "surface = %d\n", surface);
|
||||
|
||||
graymean = 0.0;
|
||||
for (idx=0; idx<surface; idx++) {
|
||||
gray = src->R[idx] + src->G[idx] + src->B[idx];
|
||||
graymean += (double)gray;
|
||||
}
|
||||
seuil = (float) (graymean / surface);
|
||||
// fprintf(stderr, "graymean = %f seuil = %f\n", graymean, seuil);
|
||||
|
||||
/*
|
||||
* please, explain this number brotching
|
||||
*/
|
||||
for (idx=0; idx<surface; idx++) {
|
||||
gray = src->R[idx] + src->G[idx] + src->B[idx];
|
||||
if (gray > seuil) {
|
||||
dst->R[idx] = gray - seuil;
|
||||
dst->B[idx] = seuil / 8.0;
|
||||
}
|
||||
else {
|
||||
dst->G[idx] = gray;
|
||||
dst->B[idx] = seuil / 8.0;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
@ -1,7 +1,5 @@
|
||||
#!/bin/bash -v
|
||||
|
||||
set -e ; set -u
|
||||
|
||||
cp libfloatimg.a /usr/local/lib
|
||||
cp floatimg.h /usr/local/include
|
||||
|
||||
@ -10,8 +8,6 @@ cp tools/mkfimg tools/fimg2pnm tools/fimgops \
|
||||
tools/png2fimg tools/fimgstats tools/fimgfx \
|
||||
tools/cumulfimgs tools/fimg2text \
|
||||
tools/fimghalfsize \
|
||||
tools/fimgmetadata tools/fimgfilters \
|
||||
tools/fimgextract \
|
||||
/usr/local/bin
|
||||
|
||||
cp v4l2/grabvidseq v4l2/video-infos \
|
||||
|
||||
@ -1,26 +0,0 @@
|
||||
# Floatimg, the base/core library
|
||||
|
||||
## Data structures
|
||||
|
||||
Image's pixels (floating point number, a `float` for C)
|
||||
are ordonned as an array of lines of single
|
||||
componant values. Every componant is in a separate array,
|
||||
who are *glued* together by an in-memory image descriptor.
|
||||
|
||||
```
|
||||
#define MAGIC_FIMG 0x00F11F00
|
||||
typedef struct {
|
||||
uint32_t magic;
|
||||
int width;
|
||||
int height;
|
||||
int type;
|
||||
float fval;
|
||||
int count;
|
||||
float *R, *G, *B, *A;
|
||||
FimgMetaData mdatas; // added 20230912
|
||||
int reserved;
|
||||
} FloatImg;
|
||||
```
|
||||
For the current state of this struc, look at the main
|
||||
[header file](../floatimg.h), located at the root of the project.
|
||||
|
||||
@ -1,29 +0,0 @@
|
||||
/*
|
||||
* alphachan.c
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity; /* must be declared around main() */
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
int fimg_add_alpha_chan(FloatImg *img)
|
||||
{
|
||||
|
||||
fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
|
||||
|
||||
return -4;
|
||||
}
|
||||
/* ---------------------------------------------------------------- */
|
||||
int fimg_kill_alpha_chan(FloatImg *img)
|
||||
{
|
||||
|
||||
fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
|
||||
|
||||
return -4;
|
||||
}
|
||||
/* ---------------------------------------------------------------- */
|
||||
164
lib/metadata.c
164
lib/metadata.c
@ -1,164 +0,0 @@
|
||||
/*
|
||||
* metadata.c
|
||||
* ----------
|
||||
*
|
||||
* This is not a stable version. You must expect problems,
|
||||
* and the first one was time_t 32 vs. 64 bits.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <unistd.h>
|
||||
#include <time.h>
|
||||
#include <sys/time.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity; /* must be declared around main() */
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
int fimg_show_metadata(FimgMetaData *pmd, char *title, int notused)
|
||||
{
|
||||
int foo;
|
||||
double doubletime;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p '%s' 0x%08x )\n", __func__,
|
||||
pmd, title, notused);
|
||||
#endif
|
||||
|
||||
if (notused) {
|
||||
fprintf(stderr, "notused was %d, must be 0 in %s\n",
|
||||
notused, __func__);
|
||||
}
|
||||
if (NULL != title) {
|
||||
fprintf(stderr, "======== metadata for %s\n", title);
|
||||
}
|
||||
if (verbosity) {
|
||||
fprintf(stderr, "sizeof(metadata) = %ld\n", \
|
||||
sizeof(FimgMetaData));
|
||||
fprintf(stderr, " Magic [%08x]\n", pmd->magic);
|
||||
}
|
||||
|
||||
/* SHOW TIMESTAMP HERE */
|
||||
fprintf(stderr, "secs from epoch = %ld\n", pmd->timestamp.tv_sec);
|
||||
fprintf(stderr, "date & time = %s", ctime(&pmd->timestamp.tv_sec));
|
||||
doubletime = (double)pmd->timestamp.tv_sec + \
|
||||
(double)pmd->timestamp.tv_usec / 1e6;
|
||||
fprintf(stderr, "dtime of day = %12.3f\n", doubletime);
|
||||
fprintf(stderr, "creator pid = %ld\n", pmd->cpid);
|
||||
fprintf(stderr, "float value = %.3f\n", pmd->fval);
|
||||
fprintf(stderr, "counter = %d\n", pmd->count);
|
||||
fprintf(stderr, "id camera = '%s'\n", pmd->idcam);
|
||||
fprintf(stderr, "origin = 0x%x\n", pmd->origin);
|
||||
|
||||
fputs("reserved words are:\n ", stderr);
|
||||
for (foo=0; foo<8; foo++) {
|
||||
fprintf(stderr, " 0x%08x", pmd->reserved[foo]);
|
||||
if (3 == foo) fputs("\n ", stderr);
|
||||
}
|
||||
fputc('\n', stderr);
|
||||
return 0;
|
||||
}
|
||||
/* ---------------------------------------------------------------- */
|
||||
/*
|
||||
* those values may be loaded from a config file ?
|
||||
*/
|
||||
int fimg_default_metadata(FimgMetaData *pmd, int bla)
|
||||
{
|
||||
int foo;
|
||||
struct timeval tvl;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %d )\n", __func__, pmd, bla);
|
||||
#endif
|
||||
|
||||
memset(pmd, 0, sizeof(FimgMetaData));
|
||||
|
||||
/* set timestamp here ? */
|
||||
/* CHALLENGE ACCEPTED */
|
||||
memset(&tvl, 0, sizeof(struct timeval));
|
||||
foo = gettimeofday(&tvl, NULL);
|
||||
if (foo) {
|
||||
/* error on get time of day ? */
|
||||
perror("omg");
|
||||
}
|
||||
else {
|
||||
if (verbosity > 1) {
|
||||
fprintf(stderr, "%s : set TimeOfDay to %12ld %8ld\n", \
|
||||
__func__, tvl.tv_sec, tvl.tv_usec);
|
||||
}
|
||||
memcpy(&(pmd->timestamp), &tvl, sizeof(struct timeval));
|
||||
}
|
||||
|
||||
pmd->magic = MAGIC_MDATA;
|
||||
pmd->cpid = getpid(); // we are the creator, no ?
|
||||
pmd->count = 1; // mmmm...
|
||||
pmd->fval = 255.0; // Ok
|
||||
strcpy(pmd->idcam, "<noname camera>");
|
||||
pmd->origin = 0xdeadbeef; // classic joke, sorry
|
||||
pmd->reserved[0] = bla;
|
||||
pmd->reserved[7] = 0x55445544; // magic number is a crime
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ---------------------------------------------------------------- */
|
||||
int fimg_get_metadata_from_file(char *fname, FimgMetaData *pmd)
|
||||
{
|
||||
FILE *fp;
|
||||
FimgFileHead filehead;
|
||||
FimgMetaData metadata;
|
||||
int foo;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( '%s' %p )\n", __func__, fname, pmd);
|
||||
#endif
|
||||
|
||||
if (NULL==(fp=fopen(fname, "r"))) {
|
||||
perror(fname);
|
||||
return -1;
|
||||
}
|
||||
|
||||
foo = fread(&filehead, sizeof(FimgFileHead), 1, fp);
|
||||
if (1 != foo) {
|
||||
fprintf(stderr, "short read (%d) on %s (head)\n", foo, fname);
|
||||
fclose(fp);
|
||||
return -2;
|
||||
}
|
||||
|
||||
if (memcmp(filehead.magic, "FIMG", 4)) {
|
||||
fprintf(stderr, "'%s' is not a fimg file.\n", fname);
|
||||
fclose(fp);
|
||||
return -3;
|
||||
}
|
||||
|
||||
if ('a' != filehead.magic[4]) {
|
||||
fprintf(stderr, "file '%s' have no metadata.\n", fname);
|
||||
fclose(fp);
|
||||
return -4;
|
||||
}
|
||||
|
||||
foo = fread(&metadata, sizeof(FimgMetaData), 1, fp);
|
||||
if (1 != foo) {
|
||||
fprintf(stderr, "short read on %s (metadata)\n", fname);
|
||||
fclose(fp);
|
||||
return -5;
|
||||
}
|
||||
|
||||
fclose(fp); /* got all needed datas */
|
||||
|
||||
if (MAGIC_MDATA != metadata.magic) {
|
||||
fprintf(stderr, "%s: magic was %08X, wtf?\n", __func__,
|
||||
metadata.magic);
|
||||
return -4;
|
||||
}
|
||||
|
||||
|
||||
memcpy(pmd, &metadata, sizeof(FimgMetaData));
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* ---------------------------------------------------------------- */
|
||||
7
scripts/.gitignore
vendored
7
scripts/.gitignore
vendored
@ -1,7 +0,0 @@
|
||||
|
||||
|
||||
*.fits
|
||||
*.tiff
|
||||
*.tif
|
||||
*.png
|
||||
|
||||
@ -1,8 +1,7 @@
|
||||
# Exemples de scripts
|
||||
|
||||
_Attention_, ce ne sont que des exemples, pas forcément adaptés
|
||||
à une utilisation dans le monde réel. Mais vous pouvez vous en
|
||||
inspirer pour vos usecases personnels.
|
||||
à une utilisation dans le monde réel.
|
||||
|
||||
## shoot.sh
|
||||
|
||||
@ -21,13 +20,5 @@ en dur dans le code.
|
||||
Comment générer des videos psychotiques avec un peu de bash.
|
||||
Ce script est expliqué dans la documentation PDF.
|
||||
|
||||
## capture.sh & conf.sh
|
||||
|
||||
Ce [script](./capture.sh) sert à capturer une séquence d'image depuis
|
||||
une webcam.
|
||||
Deux choses à noter : il utilise un fichier de configuration
|
||||
(`source [./conf.sh](./conf.sh)) pour ajuster son fonctionnement, et il
|
||||
extrait juste une portion de l'image capturée. Une belle avancée,
|
||||
puisque cela ajoute quelques possibilités de recadrage dès
|
||||
la prise de vue.
|
||||
|
||||
|
||||
@ -1,30 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
# CAPTURE
|
||||
|
||||
source ./conf.sh
|
||||
|
||||
DEVICE="/dev/video0"
|
||||
GOPT=" -v -s 1920x1080 -p 0 -n 10"
|
||||
OUTD=$GRABDIR
|
||||
TMPG="/dev/shm/tmpgrab.fimg"
|
||||
|
||||
for idx in $(seq 0 2399)
|
||||
do
|
||||
|
||||
# take the picz
|
||||
${GRAB} -d ${DEVICE} ${GOPT} -o ${TMPG}
|
||||
|
||||
# display $TMPG
|
||||
|
||||
# only take the good spot
|
||||
fimg=$(printf "%s/%05d.fimg" ${OUTD} ${idx})
|
||||
${EXTR} -o ${fimg} ${TMPG} 800,600,560,240
|
||||
|
||||
# display ${fimg} ; exit
|
||||
|
||||
echo
|
||||
sleep $DELAY_GRAB
|
||||
|
||||
done
|
||||
|
||||
@ -1,34 +0,0 @@
|
||||
|
||||
# Sat Jul 8 10:41:58 UTC 2023
|
||||
|
||||
#
|
||||
# location of some tools
|
||||
#
|
||||
|
||||
GRAB="$HOME/Devel/FloatImg/v4l2/grabvidseq"
|
||||
MKFX="$HOME/Devel/FloatImg/tools/fimgfx"
|
||||
MDAT="$HOME/Devel/FloatImg/tools/fimgmetadata"
|
||||
EXTR="$HOME/Devel/FloatImg/tools/fimgextract"
|
||||
|
||||
INTERPOLATOR="$HOME/Devel/FloatImg/Fonderie/interpolator"
|
||||
FONDERIE="$HOME/Devel/FloatImg/Fonderie/fonderie"
|
||||
SINGLEPASS="$HOME/Devel/FloatImg/Fonderie/singlepass"
|
||||
|
||||
#
|
||||
# working directories
|
||||
#
|
||||
GRABDIR="rush"
|
||||
GIFDIR="gif89a"
|
||||
|
||||
#
|
||||
# text plotting conf
|
||||
FONT="Noto-Sans-Bold"
|
||||
KERNING=1
|
||||
SIGNATURE="... tTh 2023 ..."
|
||||
|
||||
#
|
||||
# filter chains for fondulations
|
||||
#
|
||||
IF="cos01:colmixa:pow2"
|
||||
OF="shiftln0:liss3x3"
|
||||
|
||||
@ -2,9 +2,9 @@
|
||||
|
||||
CMDPATH="/usr/local/bin"
|
||||
|
||||
WS="${HOME}/TMP" # our workspace
|
||||
WS="./tmp" # our workspace
|
||||
|
||||
GRABOPT=" -d /dev/video0 -v -n 240 -p 0.04 "
|
||||
GRABOPT=" -d /dev/video0 -vu -n 240 -p 0.04 "
|
||||
|
||||
GRAB=${WS}/"quux.fimg"
|
||||
COS01=${WS}/"cos01.fimg"
|
||||
@ -15,9 +15,9 @@ POW2="${WS}/pow2.fimg"
|
||||
# --------- conversion fimg -> pnm
|
||||
f2p ()
|
||||
{
|
||||
dst=EC_$(basename $1 .fimg).pnm
|
||||
dst=$(basename $1 .fimg).pnm
|
||||
echo == converting $1 to $dst
|
||||
${CMDPATH}/fimg2pnm $1 ${WS}/$dst
|
||||
${CMDPATH}/fimg2pnm $1 $dst
|
||||
}
|
||||
|
||||
# --------- capturer une image
|
||||
@ -43,4 +43,4 @@ f2p $COS010
|
||||
# ----------- présentation finale
|
||||
#
|
||||
echo == Making gif89a
|
||||
convert -delay 40 ${WS}/EC_*.pnm foo.gif
|
||||
convert -delay 40 *.pnm foo.gif
|
||||
|
||||
@ -1,27 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
source="00000.fimg"
|
||||
tmpimg="/dev/shm/demofx.fimg"
|
||||
|
||||
effects=$(fimgfx -l)
|
||||
|
||||
for fx in $effects
|
||||
do
|
||||
|
||||
echo "============= " $fx
|
||||
dst="${fx}.png"
|
||||
echo " " ${source} ${dst}
|
||||
|
||||
fimgfx -v ${fx} ${source} ${tmpimg}
|
||||
|
||||
convert $tmpimg \
|
||||
-fill black -stroke white \
|
||||
-strokewidth 1 \
|
||||
-pointsize 34 \
|
||||
-font "Noto-Sans-Bold" \
|
||||
-gravity South-East \
|
||||
-annotate +32+10 "${fx}" \
|
||||
${dst}
|
||||
|
||||
done
|
||||
|
||||
@ -1,13 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
echo "=== make a lot of float img ==="
|
||||
|
||||
MKFIMG="../tools/mkfimg"
|
||||
SIZE=" 640x480 "
|
||||
|
||||
for type in $(${MKFIMG} -L)
|
||||
do
|
||||
picname="/tmp/${type}.fimg"
|
||||
echo $picname
|
||||
${MKFIMG} -v -t $type $picname $SIZE
|
||||
done
|
||||
@ -26,9 +26,9 @@ for idx in $(seq 0 $NBRE)
|
||||
do
|
||||
# build the two input filenames ...
|
||||
#
|
||||
imgA=$(printf "$SRCDIR/%05d.fimg" $idx)
|
||||
imgA=$(printf "$SRCDIR/%04d.fimg" $idx)
|
||||
vb=$(( $(( idx + OFFS )) % NBRE))
|
||||
imgB=$(printf "$SRCDIR/%05d.fimg" $vb)
|
||||
imgB=$(printf "$SRCDIR/%04d.fimg" $vb)
|
||||
|
||||
# ... and the output filename
|
||||
#
|
||||
|
||||
@ -1,88 +1,37 @@
|
||||
/*
|
||||
* floatimg.h
|
||||
|
||||
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
|
||||
Version 2, December 2004
|
||||
|
||||
Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
|
||||
|
||||
Everyone is permitted to copy and distribute verbatim or modified
|
||||
copies of this license document, and changing it is allowed as long
|
||||
as the name is changed.
|
||||
|
||||
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. You just DO WHAT THE FUCK YOU WANT TO.
|
||||
|
||||
* ugly code from tTh
|
||||
* http://la.buvette.org/photos/cumul/
|
||||
* https://git.tetalab.org/tTh/FloatImg
|
||||
* http://la.buvette.org/photos/cumul
|
||||
*/
|
||||
|
||||
#define FIMG_VERSION (245)
|
||||
#define RELEASE_NAME ("noname")
|
||||
#define PATCH_LEVEL ("aaaa")
|
||||
|
||||
|
||||
/* XXX add a test for stdint.h / uint32_t XXX */
|
||||
#include <stdint.h>
|
||||
|
||||
#define FIMG_VERSION 150
|
||||
|
||||
/*
|
||||
* new 11 mars 2022, and a lot of iterations
|
||||
* around the concept of metadata for my work.
|
||||
*
|
||||
* we MUST look at packing and endianess problems NOW
|
||||
* and we can think about a fixed size of this datablock
|
||||
*/
|
||||
#define MAGIC_MDATA 0xfe007007
|
||||
typedef struct {
|
||||
uint32_t magic;
|
||||
uint32_t padding;
|
||||
|
||||
struct timeval timestamp; // #include <stdlib.h>
|
||||
uint64_t cpid; // process id of the creator
|
||||
int32_t count;
|
||||
float fval;
|
||||
char idcam[32];
|
||||
int32_t origin; // enum ?
|
||||
uint32_t reserved[8];
|
||||
} FimgMetaData;
|
||||
|
||||
|
||||
/*
|
||||
* in memory descriptor of a floating image
|
||||
* ----------------------------------------
|
||||
* in memory descriptor
|
||||
*/
|
||||
#define MAGIC_FIMG 0x00F11F00
|
||||
typedef struct {
|
||||
uint32_t magic;
|
||||
unsigned long magic;
|
||||
int width;
|
||||
int height;
|
||||
int type;
|
||||
float fval;
|
||||
int count;
|
||||
float *R, *G, *B, *A;
|
||||
FimgMetaData mdatas; // added 20230912
|
||||
int reserved;
|
||||
} FloatImg;
|
||||
|
||||
/*
|
||||
* fimg file header (short version)
|
||||
* fimg file header
|
||||
*/
|
||||
typedef struct {
|
||||
char magic[8]; /* this is not an asciiz ! */
|
||||
char magic[8];
|
||||
int32_t w, h, t;
|
||||
/*
|
||||
* what about the packing ?
|
||||
*/
|
||||
} FimgFileHead;
|
||||
|
||||
|
||||
#define MAGIC_AREA51 0xA5EA0051
|
||||
typedef struct {
|
||||
uint32_t magic;
|
||||
unsigned long magic;
|
||||
int w, h;
|
||||
int x, y;
|
||||
int flags;
|
||||
@ -101,8 +50,6 @@ typedef struct {
|
||||
#define FILE_TYPE_FITS 6
|
||||
#define FILE_TYPE_BMP 7
|
||||
#define FILE_TYPE_EXR 8
|
||||
#define FILE_TYPE_DICOM 9
|
||||
#define FILE_TYPE_PGM 10
|
||||
|
||||
/* lib/contrast.c */
|
||||
#define CONTRAST_NONE 0
|
||||
@ -110,7 +57,7 @@ typedef struct {
|
||||
#define CONTRAST_POW2 2
|
||||
#define CONTRAST_COS01 3
|
||||
#define CONTRAST_COS010 4
|
||||
#define CONTRAST_XPER 5 /* use with caution */
|
||||
|
||||
/*
|
||||
* core module
|
||||
*/
|
||||
@ -148,26 +95,20 @@ int fimg_mul_3(FloatImg *a, FloatImg *b, FloatImg *d);
|
||||
int fimg_minimum(FloatImg *a, FloatImg *b, FloatImg *d);
|
||||
int fimg_maximum(FloatImg *a, FloatImg *b, FloatImg *d);
|
||||
|
||||
|
||||
/* ---------------------------------------------------- */
|
||||
/* funcs/filtrage.c */
|
||||
|
||||
typedef struct {
|
||||
float matrix[9];
|
||||
float mult;
|
||||
float offset;
|
||||
} FimgFilter3x3;
|
||||
/*
|
||||
* this module contains bugs...
|
||||
*/
|
||||
|
||||
int fimg_killborders(FloatImg *img);
|
||||
int fimg_lissage_2x2(FloatImg *img);
|
||||
int fimg_lissage_3x3(FloatImg *img);
|
||||
int fimg_show_filter(char *title, FimgFilter3x3 *filtr);
|
||||
int fimg_filter_3x3(FloatImg *s, FloatImg *d, FimgFilter3x3 *filtr);
|
||||
|
||||
int fimg_contour_2x2(FloatImg *psrc, FloatImg *pdst, int reverse);
|
||||
|
||||
/* ---------------------------------------------------- */
|
||||
int fimg_contour_2x2(FloatImg *psrc, FloatImg *pdst, int reverse);
|
||||
|
||||
/* module sfx0.c */
|
||||
int fimg_killcolors_a(FloatImg *fimg, float fval);
|
||||
@ -182,33 +123,20 @@ int fimg_highlight_color(FloatImg *src, FloatImg *dst,
|
||||
int fimg_binarize(FloatImg *pimg, int notused);
|
||||
int fimg_trinarize(FloatImg *pimg, int notused);
|
||||
|
||||
/* module sfx3.c */
|
||||
int fimg_make_rndfluffy_lines(FloatImg *src, FloatImg *dst, int rndt);
|
||||
int fimg_crump_hard(FloatImg *src, FloatImg *dst, float kval, int notused);
|
||||
|
||||
/* module sfx4.c */
|
||||
int fimg_sfx_triplemul(FloatImg *s, FloatImg *d, int notused);
|
||||
int fimg_split_level(FloatImg *src, FloatImg *dst, int notused);
|
||||
int fimg_make_triptyq(FloatImg *src, FloatImg *dst, int notused);
|
||||
|
||||
/* funcs/rotate.c module */
|
||||
/* #coronamaison */
|
||||
int fimg_rotate_90(FloatImg *src, FloatImg *dst, int notused);
|
||||
|
||||
int fimg_killrgb_v(FloatImg *src, FloatImg *dst, int k);
|
||||
int fimg_decomp_rgbz_color(FloatImg *psrc, FloatImg *pdst, int k);
|
||||
int fimg_decomp_rgbz_gray(FloatImg *psrc, FloatImg *pdst, int k);
|
||||
|
||||
int fimg_save_plane_as_dicom(FloatImg *src, char *outname,
|
||||
char plane, int flags);
|
||||
|
||||
/* universal exporter XXX */
|
||||
int fimg_export_picture(FloatImg *pic, char *fname, int flags);
|
||||
|
||||
/* PNM files module */
|
||||
int fimg_save_as_pnm(FloatImg *head, char *fname, int flags);
|
||||
int fimg_save_as_pgm(FloatImg *head, char *fname, int flags);
|
||||
int fimg_load_from_pnm(char *fname, FloatImg *head, int notused);
|
||||
int fimg_save_plane_as_pgm(FloatImg *psrc, char *fname, char plane);
|
||||
|
||||
double fimg_timer_set(int whot);
|
||||
double fimg_timer_get(int whot);
|
||||
@ -225,30 +153,16 @@ int fimg_mix_rgb_gray(FloatImg *img, float mix);
|
||||
int fimg_shift_to_zero(FloatImg *s, FloatImg *d, float coefs[6]);
|
||||
int fimg_auto_shift_to_zero(FloatImg *s, FloatImg *d);
|
||||
|
||||
/* funcs/falsecolors.c */
|
||||
int fimg_falsecolors_0(FloatImg *src, FloatImg *dst, int k, float valf);
|
||||
|
||||
/* funcs/fmorpho.c */
|
||||
int fimg_filtre_morpho_0(FloatImg *sfimg, FloatImg *dfimg, int index);
|
||||
|
||||
int fimg_auto_thermique(FloatImg *src, FloatImg *dst, int k);
|
||||
|
||||
/* --> funcs/plasmas.c */
|
||||
int fimg_prototype_plasma(FloatImg *img, double time, int type);
|
||||
|
||||
/* --> funcs/pixelize.c
|
||||
voir fimg_pixelize_h_rnd() */
|
||||
int fimg_pixelize_h_0(FloatImg *psrc, FloatImg *pdst, int k);
|
||||
int fimg_pixelize_h_rnd(FloatImg *psrc, FloatImg *pdst, int largeur);
|
||||
|
||||
/* * * * experimental ! */
|
||||
int fimg_classif_trial(FloatImg *src, FloatImg*dst, float fval, int notused);
|
||||
int fimg_qsort_rgb_a(FloatImg *psrc, FloatImg *pdst, int notused);
|
||||
int fimg_qsort_rgb_b(FloatImg *psrc, FloatImg *pdst, int notused);
|
||||
|
||||
/* module funcs/equalize.c */
|
||||
/* module funcs/??????.c */
|
||||
int fimg_equalize_compute(FloatImg *src, void *vptr, float vmax);
|
||||
int fimg_equalize(FloatImg *src, double vmax);
|
||||
|
||||
int fimg_mk_gray_from(FloatImg *src, FloatImg*dst, int k);
|
||||
int fimg_desaturate(FloatImg *src, FloatImg *dst, int notused);
|
||||
@ -260,6 +174,7 @@ int fimg_halfsize_1(FloatImg *src, FloatImg *dst, int notused);
|
||||
int fimg_extractor(FloatImg *in, FloatImg *out, FimgArea51 *rect);
|
||||
int fimg_mirror(FloatImg *src, FloatImg *dst, int notused);
|
||||
|
||||
|
||||
int fimg_incrustator_0(FloatImg *psrc, FloatImg *pdst,
|
||||
int xpos, int ypos, int flags);
|
||||
|
||||
@ -268,24 +183,13 @@ int fimg_displacement_0(FloatImg *psrc, FloatImg *pdst, int flags);
|
||||
/* module funcs/rampes.c */
|
||||
int fimg_hdeg_a(FloatImg *img, double dcoef);
|
||||
int fimg_vdeg_a(FloatImg *img, double dcoef);
|
||||
int fimg_do_stripes(FloatImg *img, float fmax, int mode);
|
||||
|
||||
/* FIMG native file module */
|
||||
/* FIMG files module */
|
||||
int fimg_fileinfos(char *fname, int *datas);
|
||||
int fimg_dump_to_file(FloatImg *head, char *fname, int notused);
|
||||
int fimg_dumpmd_to_file(FloatImg *fi, char *nm, FimgMetaData *pmd, int nu);
|
||||
|
||||
int fimg_load_from_dump(char *fname, FloatImg *where);
|
||||
int fimg_create_from_dump(char *fname, FloatImg *head);
|
||||
|
||||
/* FIMG metadata module */
|
||||
int fimg_show_metadata(FimgMetaData *pmd, char *title, int notused);
|
||||
int fimg_default_metadata(FimgMetaData *pmd, int bla);
|
||||
int fimg_get_metadata_from_file(char *fname, FimgMetaData *pmd);
|
||||
|
||||
/*
|
||||
* FITS, an image fileformat for astronomy
|
||||
*/
|
||||
int fimg_save_R_as_fits(FloatImg *src, char *outname, int flags);
|
||||
int fimg_save_G_as_fits(FloatImg *src, char *outname, int flags);
|
||||
int fimg_save_B_as_fits(FloatImg *src, char *outname, int flags);
|
||||
@ -294,23 +198,19 @@ int fimg_save_plane_as_fits(FloatImg *src, char *oname, char plane, int flags);
|
||||
int fimg_write_as_tiff(FloatImg *src, char *fname, int flags);
|
||||
int fimg_save_as_exr(FloatImg *src, char *outname, int flags);
|
||||
|
||||
|
||||
/* mathematics operations */
|
||||
float fimg_get_plane_maxvalue(FloatImg *psrc, char plane);
|
||||
float fimg_get_maxvalue(FloatImg *head);
|
||||
int fimg_get_minmax_rgb(FloatImg *head, float mmvals[6]);
|
||||
int fimg_meanvalues(FloatImg *head, float means[4]);
|
||||
int fimg_to_gray(FloatImg *head);
|
||||
int fimg_add_cste(FloatImg *fi, float value);
|
||||
int fimg_mul_cste(FloatImg *fi, float value);
|
||||
int fimg_div_cste(FloatImg *fi, float value);
|
||||
int fimg_ajust_from_grab(FloatImg *fi, double maxima, int notused);
|
||||
int fimg_absolute(FloatImg *fimg);
|
||||
void fimg_drand48(FloatImg *fi, float kmul);
|
||||
long fimg_count_negativ(FloatImg *fi);
|
||||
long fimg_clamp_negativ(FloatImg *fi);
|
||||
|
||||
int fimg_max_of_max(FloatImg *img, float maxes[3]);
|
||||
|
||||
/* various funcs modules */
|
||||
int fimg_load_from_png(char *filename, FloatImg *fimg);
|
||||
int fimg_create_from_png(char *filename, FloatImg *fimg);
|
||||
@ -325,17 +225,13 @@ int fimg_multirandom(FloatImg *fimg, long nbpass);
|
||||
|
||||
/* file is 'funcs/utils.c' */
|
||||
void fimg_print_minmax(float minmax[6], char *titre);
|
||||
float *charplane2int(char plane, FloatImg *img);
|
||||
|
||||
int parse_WxH(char *str, int *pw, int *ph);
|
||||
int parse_double(char *str, double *dptr);
|
||||
int irand2(int offset, int modulo);
|
||||
int print_rectangle(char *str, FimgArea51 *rect);
|
||||
int parse_rectangle(char *str, FimgArea51 *r, int notused);
|
||||
int format_from_extension(char *fname);
|
||||
char * extension_from_format(int fmt);
|
||||
|
||||
int fimg_clear_rectangle(FloatImg *pimg, int rect[4]);
|
||||
|
||||
|
||||
|
||||
@ -2,28 +2,30 @@
|
||||
|
||||
# Please, use the 'Gloabl.makefile' system !
|
||||
|
||||
LIB_DIR = ../../build/lib
|
||||
|
||||
OBJ_DIR = ../../build/obj
|
||||
|
||||
STATIC_LIB = $(LIB_DIR)/libfloatimg.a
|
||||
|
||||
DYN_OBJ = $(OBJ_DIR)/libfloatimg-funcs.o
|
||||
|
||||
COPT = -Wall -fpic -g -no-pie -DDEBUG_LEVEL=0
|
||||
|
||||
COPT = -Wall -Wextra -fpic -g -no-pie -DDEBUG_LEVEL=0
|
||||
DEPS = ../floatimg.h Makefile
|
||||
|
||||
OBJS = fimg-png.o fimg-tiff.o misc-plots.o filtrage.o utils.o \
|
||||
fimg-libpnm.o rampes.o rectangle.o \
|
||||
sfx0.o sfx1.o sfx2.o sfx3.o sfx4.o \
|
||||
falsecolors.o thermocolor.o fmorpho.o \
|
||||
fimg-libpnm.o rampes.o sfx0.o sfx1.o sfx2.o sfx4.o \
|
||||
geometry.o rotate.o fimg-openexr.o \
|
||||
equalize.o fimg-fits.o saturation.o histogram.o \
|
||||
fimg-dicom.o \
|
||||
hsv.o classif.o contour2x2.o qsortrgb.o exporter.o \
|
||||
displacement.o dithering.o plasmas.o incrustator.o \
|
||||
killrgb.o recurse.o pixelize.o decomprgb.o
|
||||
recurse.o
|
||||
|
||||
|
||||
all: $(OBJS) $(STATIC_LIB) $(DYN_OBJ)
|
||||
#---------------------------------------------------------------
|
||||
|
||||
all: t
|
||||
|
||||
tests.o: tests.c tests.h $(DEPS)
|
||||
gcc $(COPT) -I/usr/include/netpbm -c $<
|
||||
|
||||
t: t.c $(DEPS) ../libfloatimg.a tests.o
|
||||
gcc $(COPT) $< \
|
||||
tests.o \
|
||||
@ -33,29 +35,22 @@ t: t.c $(DEPS) ../libfloatimg.a tests.o
|
||||
-ltiff \
|
||||
-lz -lm -o $@
|
||||
|
||||
tpnm: tpnm.c Makefile fimg-libpnm.o
|
||||
gcc $(COPT) -I/usr/include/netpbm \
|
||||
fimg-libpnm.o -lnetpbm $< -o $@
|
||||
tests.o: tests.c tests.h $(DEPS)
|
||||
gcc $(COPT) -I/usr/include/netpbm -c $<
|
||||
|
||||
#---------------------------------------------------------------
|
||||
# upper-level functions
|
||||
|
||||
../libfloatimg.a: $(OBJS)
|
||||
$(STATIC_LIB): $(OBJS)
|
||||
$(AR) r $@ $?
|
||||
|
||||
# ###
|
||||
|
||||
rectangle.o: rectangle.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
$(DYN_OBJ): $(OBJS)
|
||||
mkdir -p $(OBJ_DIR)
|
||||
ld -Ur -o $@ $?
|
||||
|
||||
decomprgb.o: decomprgb.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
pixelize.o: pixelize.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
killrgb.o: killrgb.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
clean:
|
||||
rm -rf $(OBJS) $(STATIC_LIB) $(DYN_OBJ)
|
||||
|
||||
recurse.o: recurse.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
@ -66,9 +61,6 @@ incrustator.o: incrustator.c $(DEPS)
|
||||
displacement.o: displacement.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
fmorpho.o: fmorpho.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
fimg-png.o: fimg-png.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
@ -81,9 +73,6 @@ fimg-tiff.o: fimg-tiff.c $(DEPS)
|
||||
fimg-openexr.o: fimg-openexr.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
fimg-dicom.o: fimg-dicom.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
fimg-fits.o: fimg-fits.c $(DEPS)
|
||||
gcc $(COPT) -I/usr/include/cfitsio/ -c $<
|
||||
|
||||
@ -126,9 +115,6 @@ sfx1.o: sfx1.c $(DEPS)
|
||||
sfx2.o: sfx2.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
sfx3.o: sfx3.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
sfx4.o: sfx4.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
@ -147,11 +133,6 @@ qsortrgb.o: qsortrgb.c $(DEPS)
|
||||
exporter.o: exporter.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
falsecolors.o: falsecolors.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
thermocolor.o: thermocolor.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
|
||||
hsv.o: hsv.c $(DEPS)
|
||||
gcc $(COPT) -c $<
|
||||
26
src/funcs/README.md
Normal file
26
src/funcs/README.md
Normal file
@ -0,0 +1,26 @@
|
||||
# Fonctions
|
||||
|
||||
Plein de fonctions qu'il serait bon de documenter :)
|
||||
|
||||
## PNG
|
||||
|
||||
__Attention__ : la bibliothèque `pnglite`actuellement utiilsée pour lire les
|
||||
fichiers PNG n'accepte que **certains** types de fichiers.
|
||||
Et en particulier, elle brotche sur ceux produits par ImageMagick !
|
||||
|
||||
## Contours
|
||||
|
||||
Détecter des contours est une activité respectable.
|
||||
|
||||
## Exporter
|
||||
|
||||
Une méta-fonction qui va sauvegarder (dans la mesure de ses conséquences)
|
||||
une image en fonction de l'extension du nom de fichier.
|
||||
|
||||
## Sfx
|
||||
|
||||
Effets spéciaux divers.
|
||||
|
||||
## Dithering
|
||||
|
||||
Work in progress...
|
||||
@ -5,7 +5,6 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <math.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
@ -15,7 +14,7 @@ extern int verbosity;
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* nouveau 2 octobre 2020, juste avant sonoptic de la pluie craignos */
|
||||
|
||||
int fimg_classif_trial(FloatImg *psrc, FloatImg *pdst, float fval, int flags)
|
||||
int fimg_classif_trial(FloatImg *psrc, FloatImg *pdst, float fval, int notused)
|
||||
{
|
||||
float minmax[6], delta[3], baryc[3];
|
||||
float range, dist, rgb[3], dr, dg, db;
|
||||
@ -26,8 +25,6 @@ fprintf(stderr, ">>> %s ( %p %p %f %d )\n", __func__,
|
||||
psrc, pdst, fval, notused);
|
||||
#endif
|
||||
|
||||
if (flags) { fprintf(stderr, "flags: 0x%04x in %s\n", flags, __func__); }
|
||||
|
||||
if (FIMG_TYPE_RGB != psrc->type) {
|
||||
fprintf(stderr, "%s: bad src type %d\n", __func__, psrc->type);
|
||||
return -7;
|
||||
@ -4,7 +4,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
@ -4,7 +4,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
@ -22,6 +21,7 @@ float minmax[6];
|
||||
float rgb[3];
|
||||
float dltr, dltg, dltb; /* delta des minmax */
|
||||
float dispx, dispy;
|
||||
|
||||
int dstx, dsty;
|
||||
int in, out;
|
||||
|
||||
@ -39,14 +39,10 @@ if (fimg_images_not_compatible(psrc, pdst)) {
|
||||
}
|
||||
|
||||
foo = fimg_get_minmax_rgb(psrc, minmax);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s : err %d on get minmax\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
if (verbosity) {
|
||||
fimg_print_minmax(minmax, (char *)__func__);
|
||||
}
|
||||
// dltr = minmax[1] - minmax[0];
|
||||
dltr = minmax[1] - minmax[0];
|
||||
dltg = minmax[3] - minmax[2];
|
||||
dltb = minmax[5] - minmax[4];
|
||||
|
||||
@ -82,7 +78,9 @@ for (y=0; y<psrc->height; y++) {
|
||||
fimg_put_rgb(pdst, dstx, dsty, rgb);
|
||||
in++;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (verbosity) fprintf(stderr, "%s -> in %d out %d\n", __func__, in, out);
|
||||
@ -4,7 +4,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
@ -17,23 +16,11 @@ int fimg_dither_0(FloatImg *psrc, FloatImg *pdst, int flags)
|
||||
{
|
||||
int x, y;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %p 0x%04x )\n", __func__, psrc, pdst, flags);
|
||||
#endif
|
||||
|
||||
if (flags) { fprintf(stderr, "flags: 0x%04x in %s\n", flags, __func__); }
|
||||
|
||||
if (fimg_images_not_compatible(psrc, pdst)) {
|
||||
fprintf(stderr, "%s: shit happen\n", __func__);
|
||||
return -2;
|
||||
}
|
||||
|
||||
for (y=0; y<psrc->height; y++) {
|
||||
|
||||
for (x=0; x<psrc->width; x++)
|
||||
{
|
||||
|
||||
/* PLEASE DO SOMETHING HERE */
|
||||
|
||||
}
|
||||
}
|
||||
@ -7,54 +7,12 @@
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* new func: Wed 14 Sep 2022 11:28:04 AM CEST
|
||||
*/
|
||||
int fimg_equalize(FloatImg *src, double vmax)
|
||||
{
|
||||
float mm[6];
|
||||
double maxi, coef;
|
||||
int foo;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p %f )\n", __func__, src, vmax);
|
||||
#endif
|
||||
|
||||
memset(mm, 0, 6*sizeof(float));
|
||||
foo = fimg_get_minmax_rgb(src, mm);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d get_minmax\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
maxi = mm[1] > mm[3] ? (double)mm[1] : (double)mm[3];
|
||||
maxi = maxi > mm[5] ? maxi : (double)mm[5];
|
||||
coef = vmax / maxi;
|
||||
|
||||
if (verbosity) {
|
||||
fprintf(stderr, "maximums %.3f %.3f %.3f %.3f\n",
|
||||
mm[1], mm[3], mm[5], maxi);
|
||||
fprintf(stderr, "vmax %f maxi %f multcoef = %g\n", vmax, maxi, coef);
|
||||
}
|
||||
|
||||
foo = fimg_mul_cste(src, (float)coef);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: err %d mul_cste\n", __func__, foo);
|
||||
return foo;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
/*
|
||||
*
|
||||
* - wtf is this "void *vptr" thing ?
|
||||
*/
|
||||
int fimg_equalize_compute(FloatImg *src, void *vptr, float vmax)
|
||||
{
|
||||
float minmax[6];
|
||||
@ -73,8 +31,6 @@ if (foo) {
|
||||
return foo;
|
||||
}
|
||||
|
||||
fprintf(stderr, "vptr is %p vmax is %f\n", vptr, vmax);
|
||||
|
||||
dr = minmax[1] - minmax[0];
|
||||
dg = minmax[3] - minmax[2];
|
||||
db = minmax[5] - minmax[4];
|
||||
@ -88,7 +44,7 @@ if ( (minmax[0]<0.0) || (minmax[2]<0.0) || (minmax[4]<0.0) ) {
|
||||
return -4;
|
||||
}
|
||||
|
||||
fprintf(stderr, "deltas %12.4g %12.4g %12.4g\n", dr, dg, db);
|
||||
// printf("deltas %12.4g %12.4g %12.4g\n", dr, dg, db);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -4,7 +4,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
@ -25,8 +24,6 @@ fprintf(stderr, ">>> %s ( %p '%s' 0x%X )\n", __func__,
|
||||
pic, fname, flags);
|
||||
#endif
|
||||
|
||||
if (flags) { fprintf(stderr, "flags: 0x%04x in %s\n", flags, __func__); }
|
||||
|
||||
filetype = format_from_extension(fname);
|
||||
if (verbosity > 1) {
|
||||
fprintf(stderr, "file %s have type %d\n", fname, filetype);
|
||||
@ -56,15 +53,9 @@ switch(filetype) {
|
||||
case FILE_TYPE_BMP:
|
||||
fprintf(stderr, "%s: file type BMP not implemented\n", __func__);
|
||||
foo = -666;
|
||||
break;
|
||||
case FILE_TYPE_EXR:
|
||||
fprintf(stderr, "%s: file type EXR experimental\n", __func__);
|
||||
foo = fimg_save_as_exr(pic, fname, 0);
|
||||
break;
|
||||
case FILE_TYPE_PGM:
|
||||
fprintf(stderr, "XXX %s EXPERIMENT!\n", __func__);
|
||||
foo = fimg_save_as_pgm(pic, fname, 0);
|
||||
break;
|
||||
default:
|
||||
foo = -1789;
|
||||
break;
|
||||
@ -1,43 +1,11 @@
|
||||
/*
|
||||
* Floating filters are all WIP !
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <float.h>
|
||||
|
||||
#include "../floatimg.h"
|
||||
|
||||
extern int verbosity;
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
int fimg_show_filter(char *title, FimgFilter3x3 *filtr)
|
||||
{
|
||||
float *M; /* alias of filter matrix */
|
||||
int idx;
|
||||
float sum, value;
|
||||
|
||||
if (title) fprintf(stderr, "--------- %s ---------\n", title);
|
||||
|
||||
M = filtr->matrix; /* aliasing here */
|
||||
|
||||
fprintf(stderr, "%8.3f %8.3f %8.3f\n", M[0], M[1], M[2]);
|
||||
fprintf(stderr, "%8.3f %8.3f %8.3f\n", M[3], M[4], M[5]);
|
||||
fprintf(stderr, "%8.3f %8.3f %8.3f\n", M[6], M[7], M[8]);
|
||||
|
||||
sum = 0.0;
|
||||
for (idx=0; idx<9; idx++) sum += M[idx];
|
||||
fprintf(stderr, " sum: %8.3f\n", sum);
|
||||
fprintf(stderr, " mult: %8.3f\n", filtr->mult);
|
||||
fprintf(stderr, " offset: %8.3f\n", filtr->offset);
|
||||
|
||||
value = (sum * filtr->mult) + filtr->offset;
|
||||
fprintf(stderr, " value: %8.3f\n", value);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------------- */
|
||||
int fimg_filter_3x3(FloatImg *src, FloatImg *dst, FimgFilter3x3 *filtr)
|
||||
{
|
||||
@ -59,21 +27,19 @@ if (dst->type != FIMG_TYPE_RGB) {
|
||||
return -99;
|
||||
}
|
||||
if (fimg_images_not_compatible(src, dst)) {
|
||||
fprintf(stderr, "%s: src & dst not compatibles\n", __func__);
|
||||
fprintf(stderr, "%s: src & dst not comatibles\n", __func__);
|
||||
return -98;
|
||||
}
|
||||
|
||||
if (verbosity > 1) {
|
||||
fimg_show_filter((char *)__func__, filtr);
|
||||
}
|
||||
|
||||
/* aliasing some vars for cleaner code */
|
||||
pr = src->R; pg = src->G; pb = src->B;
|
||||
w = src->width; h = src->height;
|
||||
M = filtr->matrix;
|
||||
|
||||
for (y=1; y < h-1; y++) {
|
||||
|
||||
for (x=1; x < w-1; x++) {
|
||||
|
||||
of = x + (y * w);
|
||||
|
||||
dval = M[0] * pr[of-(w+1)] +
|
||||
@ -140,7 +106,9 @@ if (img->type != FIMG_TYPE_RGB) {
|
||||
pr = img->R; pg = img->G; pb = img->B;
|
||||
|
||||
for (y=1; y < img->height-1; y++) {
|
||||
|
||||
for (x=1; x < img->width-1; x++) {
|
||||
|
||||
offset = x + (y * img->width);
|
||||
|
||||
cr = pr[offset] + pr[offset+1] +
|
||||
@ -155,6 +123,7 @@ for (y=1; y < img->height-1; y++) {
|
||||
pr[offset] = cr / 4.0;
|
||||
pg[offset] = cg / 4.0;
|
||||
pb[offset] = cb / 4.0;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -195,6 +164,7 @@ for (idx=0; idx<h; idx++) {
|
||||
}
|
||||
|
||||
o = w * (h - 1);
|
||||
|
||||
for (idx=0; idx<w; idx++) {
|
||||
#if FAST
|
||||
img->R[idx] = 0.0;
|
||||
@ -216,10 +186,6 @@ int fimg_lissage_2x2(FloatImg *img)
|
||||
{
|
||||
int foo;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
|
||||
#endif
|
||||
|
||||
foo = fimg_lissage_2x2_a(img);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: fail %d\n", __func__, foo);
|
||||
@ -231,54 +197,4 @@ fimg_killborders(img);
|
||||
return foo;
|
||||
}
|
||||
/* -------------------------------------------------------------------- */
|
||||
/* -------------------------------------------------------------------- */
|
||||
/*
|
||||
* XXX inplace filtering is a BAD IDEA
|
||||
*/
|
||||
int fimg_lissage_3x3(FloatImg *img)
|
||||
{
|
||||
int foo;
|
||||
FloatImg tmp;
|
||||
|
||||
#if DEBUG_LEVEL
|
||||
fprintf(stderr, ">>> %s ( %p )\n", __func__, img);
|
||||
#endif
|
||||
|
||||
static FimgFilter3x3 lowpass = {
|
||||
{
|
||||
1.0, 2.0, 1.0,
|
||||
2.0, 4.0, 2.0,
|
||||
1.0, 2.0, 1.0,
|
||||
},
|
||||
16.0, 0.0
|
||||
};
|
||||
|
||||
foo = fimg_clone(img, &tmp, 1);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: clone -> %d\n", __func__, foo);
|
||||
abort();
|
||||
}
|
||||
foo = fimg_filter_3x3(&tmp, img, &lowpass);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: lowpass -> %d\n", __func__, foo);
|
||||
abort();
|
||||
}
|
||||
|
||||
foo = fimg_copy_data(&tmp, img);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: copy data -> %d\n", __func__, foo);
|
||||
abort();
|
||||
}
|
||||
|
||||
foo = fimg_destroy(&tmp);
|
||||
if (foo) {
|
||||
fprintf(stderr, "%s: destroy -> %d\n", __func__, foo);
|
||||
abort();
|
||||
}
|
||||
|
||||
fimg_killborders(img);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* -------------------------------------------------------------------- */
|
||||
|
||||
@ -8,8 +8,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
#include <fitsio.h>
|
||||
|
||||
@ -32,8 +30,6 @@ long naxes[2];
|
||||
fprintf(stderr, ">>> %s ( %p '%s' %d )\n", __func__, src, outname, flags);
|
||||
#endif
|
||||
|
||||
if (flags) { fprintf(stderr, "flags: 0x%04x in %s\n", flags, __func__); }
|
||||
|
||||
status = 0;
|
||||
|
||||
switch (plane) {
|
||||
@ -54,7 +50,7 @@ if (fits_create_file(&fptr, outname, &status)) {
|
||||
}
|
||||
|
||||
naxes[0] = src->width; naxes[1] = src->height;
|
||||
if (verbosity > 1) fimg_describe(src, "to be saved as FITS");
|
||||
if (verbosity) fimg_describe(src, "to be saved as FITS");
|
||||
|
||||
if ( fits_create_img(fptr, bitpix, naxis, naxes, &status) ) {
|
||||
fits_report_error(stderr, status);
|
||||
@ -4,7 +4,6 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <pam.h>
|
||||
@ -14,16 +13,17 @@
|
||||
extern int verbosity;
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
static void print_struct_pam(struct pam *ppam, char *text)
|
||||
static void print_struct_pam(struct pam *ppam, char *txt)
|
||||
{
|
||||
printf("\ttext %s\n", text);
|
||||
printf("\tsize %d\n", ppam->size);
|
||||
|
||||
printf("\tformat %d 0x%04x\n", ppam->format, ppam->format);
|
||||
printf("\tplainformat %d\n", ppam->plainformat);
|
||||
printf("\twidth & height %d %d\n", ppam->width, ppam->height);
|
||||
printf("\tdepth %d\n", ppam->depth);
|
||||
printf("\tmaxval %lu\n", ppam->maxval);
|
||||
printf(" size %d\n", ppam->size);
|
||||
|
||||
printf(" format %d\n", ppam->format);
|
||||
printf(" plainformat %d\n", ppam->plainformat);
|
||||
printf(" width & height %d %d\n", ppam->width, ppam->height);
|
||||
printf(" depth %d\n", ppam->depth);
|
||||
printf(" maxval %lu\n", ppam->maxval);
|
||||
|
||||
}
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
@ -36,14 +36,13 @@ FILE *fp;
|
||||
fprintf(stderr, ">>> %s ( '%s' )\n", __func__, fname);
|
||||
#endif
|
||||
|
||||
printf(" --- infos for '%s' ------------\n", fname);
|
||||
|
||||
if (NULL==(fp=fopen(fname, "r"))) {
|
||||
perror(fname);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
pnm_readpaminit(fp, &inpam, sizeof(inpam));
|
||||
|
||||
print_struct_pam(&inpam, fname);
|
||||
|
||||
fclose(fp);
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user