Bibliothèque de traitements d'images en virgule flottante.
http://la.buvette.org/photos/cumul/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
316 lines
6.9 KiB
316 lines
6.9 KiB
/* |
|
* fimg-core.c |
|
* |
|
* |
|
*/ |
|
|
|
#include <stdio.h> |
|
#include <stdlib.h> |
|
#include <unistd.h> |
|
#include "string.h" |
|
|
|
#include "../floatimg.h" |
|
|
|
extern int verbosity; /* must be declared around main() */ |
|
|
|
/* ---------------------------------------------------------------- */ |
|
static int fimg_type_is_valid(int type) |
|
{ |
|
switch (type) { |
|
case FIMG_TYPE_GRAY: |
|
case FIMG_TYPE_RGB: |
|
case FIMG_TYPE_RGBA: return 1; |
|
} |
|
return 0; |
|
} |
|
/* --------------------------------------------------------------------- */ |
|
char *fimg_str_type(int type) |
|
{ |
|
switch (type) { |
|
case FIMG_TYPE_GRAY: return "gray"; |
|
case FIMG_TYPE_RGB: return "rgb"; |
|
case FIMG_TYPE_RGBA: return "rgba"; |
|
} |
|
return "???"; |
|
} |
|
/* --------------------------------------------------------------------- */ |
|
int fimg_print_version(int k) |
|
{ |
|
fprintf(stderr, "*** FloatImg library, alpha v%d (%s, %s)\n", |
|
FIMG_VERSION, __DATE__, __TIME__); |
|
|
|
if (51 == k) { |
|
puts("+--------------------+"); |
|
puts("| Pastis is coming. |"); |
|
puts("+--------------------+"); |
|
} |
|
|
|
return 0; |
|
} |
|
/* --------------------------------------------------------------------- */ |
|
void fimg_printhead(FloatImg *h) |
|
{ |
|
printf("%5d %5d %2d %p %p %p %p\n", h->width, h->height, h->type, |
|
h->R, h->G, h->B, h->A); |
|
} |
|
/* --------------------------------------------------------------------- */ |
|
int fimg_describe(FloatImg *head, char *txt) |
|
{ |
|
printf("----- '%s' at %p -----\n", txt, head); |
|
|
|
if( ! fimg_type_is_valid(head->type) ) { |
|
fprintf(stderr, "*** %s *** type %d invalid *** %s ***\n", |
|
__func__, head->type, txt); |
|
return -1; |
|
} |
|
|
|
printf(" type %d %s\n", head->type, fimg_str_type(head->type)); |
|
printf(" dims %d x %d\n", |
|
head->width, head->height); |
|
printf(" fval/count %f %d\n", head->fval, head->count); |
|
|
|
printf(" pixels@ %p %p %p %p\n", |
|
head->R, head->G, head->B, head->A); |
|
|
|
return 0; |
|
} |
|
/* ---------------------------------------------------------------- */ |
|
/* |
|
* values for the parameter 't' are defined in 'floatimg.h' |
|
*/ |
|
int fimg_create(FloatImg *fimg, int w, int h, int t) |
|
{ |
|
int surface, size; |
|
float *fptr; |
|
|
|
#if DEBUG_LEVEL |
|
fprintf(stderr, ">>> %-25s ( %p %d %d %d )\n", __func__, fimg, w, h, t); |
|
#endif |
|
|
|
if ( ! fimg_type_is_valid(t) ) { |
|
return -2; |
|
} |
|
|
|
/* |
|
* what to do if we've got a descriptor for an image |
|
* already allocated ? |
|
*/ |
|
|
|
memset(fimg, 0, sizeof(FloatImg)); |
|
|
|
surface = w * h; |
|
size = surface * t * sizeof(float); |
|
#if DEBUG_LEVEL > 1 |
|
fprintf(stderr, "surface is %d pixels, need %d bytes\n", surface, size); |
|
#endif |
|
|
|
fptr = (float *)malloc(size); |
|
if (NULL==fptr) { |
|
fprintf(stderr, "%s : no mem, exiting.\n", __func__); |
|
exit(1); |
|
} |
|
|
|
#if DEBUG_LEVEL > 1 |
|
fprintf(stderr, " got %d bytes at %p\n", size, fptr); |
|
#endif |
|
|
|
fimg->width = w; fimg->height = h; |
|
fimg->type = t; |
|
|
|
fimg->R = fptr; |
|
if ( (t==FIMG_TYPE_RGB) || (t==FIMG_TYPE_RGBA) ) { |
|
fimg->G = fptr + surface; |
|
fimg->B = fptr + surface + surface; |
|
} |
|
if ( t==FIMG_TYPE_RGBA ) fimg->A = fptr + (3 * surface); |
|
/* ok this a really WTF fragment of code */ |
|
|
|
return 0; |
|
} |
|
|
|
/* --------------------------------------------------------------------- */ |
|
int fimg_destroy(FloatImg *fimg) |
|
{ |
|
|
|
#if DEBUG_LEVEL |
|
fprintf(stderr, ">>> %-25s ( %p )\n", __func__, fimg); |
|
#endif |
|
|
|
if (NULL == fimg) { |
|
fprintf(stderr, "%s : parameter is null\n", __func__); |
|
return -1; |
|
} |
|
|
|
if ( ! fimg_type_is_valid(fimg->type) ) { |
|
fprintf(stderr, "%s : type %d invalid\n", __func__, |
|
fimg->type); |
|
return -2; |
|
} |
|
if (NULL == fimg->R) { |
|
fprintf(stderr, "%s : %p already freed ?\n", __func__, fimg); |
|
return -3; |
|
} |
|
free(fimg->R); |
|
memset(fimg, 0, sizeof(FloatImg)); |
|
|
|
return 0; |
|
} |
|
/* --------------------------------------------------------------------- */ |
|
int fimg_clone(FloatImg *old, FloatImg *new, int flags) |
|
{ |
|
int foo; |
|
|
|
#if DEBUG_LEVEL |
|
fprintf(stderr, ">>> %-25s ( %p %p 0x%x)\n", __func__, old, new, flags); |
|
#endif |
|
|
|
if ( ! fimg_type_is_valid(old->type) ) { |
|
fprintf(stderr, "invalid type %d in %s\n", old->type, __func__); |
|
return -2; |
|
} |
|
|
|
memset(new, 0, sizeof(FloatImg)); |
|
|
|
foo = fimg_create(new, old->width, old->height, old->type); |
|
if (foo) { |
|
fprintf(stderr, "error %d in %s\n", foo, __func__); |
|
return -3; |
|
} |
|
|
|
if (flags & 0x01) { |
|
/* XXX copy all the pixels's datas */ |
|
|
|
} |
|
|
|
return 0; |
|
} |
|
/* --------------------------------------------------------------------- */ |
|
int fimg_copy_data(FloatImg *from, FloatImg *to) |
|
{ |
|
int size; |
|
int foo; |
|
|
|
#if DEBUG_LEVEL |
|
fprintf(stderr, ">>> %-25s ( %p %p )\n", __func__, from, to); |
|
#endif |
|
|
|
foo = fimg_images_compatible(from, to); |
|
if (foo) { |
|
fprintf(stderr, "%s: pics not compatible (%d)\n", __func__, foo); |
|
return foo; |
|
} |
|
|
|
size = from->width * from->height * from->type * sizeof(float); |
|
memcpy(to->R, from->R, size); |
|
|
|
return 0; |
|
} |
|
/* --------------------------------------------------------------------- */ |
|
int fimg_clear(FloatImg *fimg) |
|
{ |
|
int size; |
|
|
|
#if DEBUG_LEVEL |
|
fprintf(stderr, ">>> %-25s ( %p )\n", __func__, fimg); |
|
#endif |
|
if ( ! fimg_type_is_valid(fimg->type) ) { |
|
fprintf(stderr, "invalid type %d in %s\n", fimg->type, __func__); |
|
return -2; |
|
} |
|
|
|
size = fimg->width * fimg->height * fimg->type * sizeof(float); |
|
memset(fimg->R, 0, size); |
|
|
|
return 0; |
|
} |
|
/* --------------------------------------------------------------------- */ |
|
int fimg_rgb_constant(FloatImg *head, float r, float g, float b) |
|
{ |
|
int idx, size; |
|
|
|
#if DEBUG_LEVEL |
|
fprintf(stderr, ">>> %-25s ( %p %f %f %f )\n", __func__, head, |
|
r, g, b); |
|
#endif |
|
|
|
if (head->type != FIMG_TYPE_RGB) { |
|
return -21; |
|
} |
|
|
|
size = head->width * head->height; |
|
|
|
for (idx=0; idx<size; idx++) { |
|
head->R[idx] = r; |
|
head->G[idx] = g; |
|
head->B[idx] = b; |
|
} |
|
|
|
return 0; |
|
} |
|
/* --------------------------------------------------------------------- */ |
|
|
|
int fimg_plot_rgb (FloatImg *head, int x, int y, |
|
float r, float g, float b) |
|
{ |
|
int offset; |
|
|
|
if (head->type < 3) { |
|
#if DEBUG_LEVEL > 1 |
|
fprintf(stderr, "%s : type %d is bad.\n", __func__, head->type); |
|
#endif |
|
return -1; |
|
} |
|
|
|
offset = x + (y * head->width); |
|
|
|
#if DEBUG_LEVEL > 1 |
|
fprintf(stderr, ">>> %s ( %p %d %d %f )\n", __func__, head, x, y, gray); |
|
fprintf(stderr, " offset %d\n", offset); |
|
#endif |
|
|
|
head->R[offset] = r; |
|
head->G[offset] = g; |
|
head->B[offset] = b; |
|
|
|
return 0; |
|
} |
|
/* ---------------------------------------------------------------- */ |
|
int fimg_add_rgb(FloatImg *head, int x, int y, float r, float g, float b) |
|
{ |
|
int offset; |
|
|
|
if (head->type != FIMG_TYPE_RGB) { |
|
#if DEBUG_LEVEL > 1 |
|
fprintf(stderr, "%s : type %d is bad.\n", __func__, head->type); |
|
#endif |
|
return -1; |
|
} |
|
|
|
offset = x + (y * head->width); |
|
head->R[offset] += r; |
|
head->G[offset] += g; |
|
head->B[offset] += b; |
|
return 0; |
|
} |
|
|
|
/* --------------------------------------------------------------------- */ |
|
/* nouveau 12 fevrier 2020 */ |
|
int fimg_get_rgb(FloatImg *head, int x, int y, float *prgb) |
|
{ |
|
int offset; |
|
|
|
if (head->type != FIMG_TYPE_RGB) { |
|
#if DEBUG_LEVEL > 1 |
|
fprintf(stderr, "%s : type %d is bad.\n", __func__, head->type); |
|
#endif |
|
return -1; |
|
} |
|
|
|
offset = x + (y * head->width); |
|
prgb[0] = head->R[offset]; |
|
prgb[1] = head->G[offset]; |
|
prgb[2] = head->B[offset]; |
|
|
|
return 0; |
|
} |
|
/* --------------------------------------------------------------------- */
|
|
|