int main ( int argc, char **argv )
{
Image *canvas = (Image *)NULL;
char outfile[MaxTextExtent];
int rows, columns = 0;
char size[MaxTextExtent];
ImageInfo *image_info;
ExceptionInfo exception;
if ( argc != 2 )
{
(void) printf ( "Usage: %s filename\n", argv[0] );
exit( 1 );
}
outfile[MaxTextExtent-1]='\0';
(void) strncpy( outfile, argv[1], MaxTextExtent-1 );
if (LocaleNCompare("drawtest",argv[0],7) == 0)
InitializeMagick((char *) NULL);
else
InitializeMagick(*argv);
/*
* Create canvas image
*/
columns=596;
rows=842;
image_info=CloneImageInfo((ImageInfo*)NULL);
GetExceptionInfo( &exception );
FormatString(size, "%dx%d", columns, rows);
(void) CloneString(&image_info->size, size);
(void) strcpy( image_info->filename, "xc:white");
canvas = ReadImage ( image_info, &exception );
if (exception.severity != UndefinedException)
CatchException(&exception);
if ( canvas == (Image *)NULL )
{
(void) printf ( "Failed to read canvas image %s\n", image_info->filename );
exit(1);
}
/*
* Scribble on image
*/
ScribbleImage( canvas );
/*
* Save image to file
*/
canvas->filename[MaxTextExtent-1]='\0';
(void) strncpy( canvas->filename, outfile, MaxTextExtent-1);
(void) WriteImage ( image_info, canvas );
DestroyExceptionInfo( &exception );
DestroyImage( canvas );
DestroyImageInfo( image_info );
DestroyMagick();
return 0;
}
static RETSIGTYPE
MagickSignalHandler(int signo)
{
/* fprintf(stderr,"Caught signal %d\n", signo); */
/*
Restore default handling for the signal
*/
(void) MagickSignal(signo,SIG_DFL);
/*
Release resources
*/
DestroyMagick();
/*
Raise signal again to invoke default handler
This may cause a core dump or immediate exit.
*/
#if defined(HAVE_RAISE)
(void) raise(signo);
#endif
SignalHandlerExit(signo);
}
void magick_cleanup()
{
#ifdef _MAGICK_USES_GM
DestroyMagick();
#else
MagickCoreTerminus();
#endif
}
void
cleanup()
{
if (image.image != (Image *) NULL) {
DestroyImage(image.image);
}
if (image.imageInfo != (ImageInfo *) NULL) {
DestroyImageInfo(image.imageInfo);
}
DestroyMagick();
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% M a i n %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/
int main(int argc,char **argv)
{
char
*option,
*text;
ExceptionInfo
exception;
ImageInfo
*image_info;
MagickBooleanType
status;
register long
i;
InitializeMagick(*argv);
GetExceptionInfo(&exception);
for (i=1; i < (long) argc; i++)
{
option=argv[i];
if ((strlen(option) == 1) || ((*option != '-') && (*option != '+')))
continue;
if ((LocaleCompare("debug",option+1) == 0) && (i < (long) (argc-1)))
(void) SetLogEventMask(argv[++i]);
if (LocaleCompare("version",option+1) == 0)
{
(void) fprintf(stdout,"Version: %s\n",
GetMagickVersion((unsigned long *) NULL));
(void) fprintf(stdout,"Copyright: %s\n\n",GetMagickCopyright());
exit(0);
}
}
image_info=CloneImageInfo((ImageInfo *) NULL);
text=(char *) NULL;
status=IdentifyImageCommand(image_info,argc,argv,&text,&exception);
if (exception.severity != UndefinedException)
CatchException(&exception);
if (text != (char *) NULL)
{
(void) fputs(text,stdout);
(void) fputc('\n',stdout);
text=(char *) RelinquishMagickMemory(text);
}
image_info=DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
DestroyMagick();
exit(!status);
return(MagickFalse);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
+ D e f a u l t F a t a l E r r o r H a n d l e r %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Method DefaultFatalErrorHandler displays an error reason and then terminates
% the program.
%
% The format of the DefaultFatalErrorHandler method is:
%
% void DefaultMagickFatalError(const ExceptionType severity,
% const char *reason, const char *description)
%
% A description of each parameter follows:
%
% o severity: Specifies the numeric error category.
%
% o reason: Specifies the reason to display before terminating the
% program.
%
% o description: Specifies any description to the reason.
%
%
*/
static void DefaultFatalErrorHandler(const ExceptionType severity,
const char *reason,const char *description)
{
if (reason == (char *) NULL)
return;
(void) fprintf(stderr,"%.1024s: %.1024s",GetClientName(),reason);
if (description != (char *) NULL)
(void) fprintf(stderr," (%.1024s)",description);
if ((severity != OptionError) && errno)
(void) fprintf(stderr," [%.1024s]",GetErrorMessageString(errno));
(void) fprintf(stderr,".\n");
DestroyMagick();
Exit(severity);
}
void dt_cleanup()
{
const int init_gui = (darktable.gui != NULL);
#ifdef HAVE_PRINT
dt_printers_abort_discovery();
#endif
#ifdef USE_LUA
dt_lua_finalize_early();
#endif
if(init_gui)
{
dt_ctl_switch_mode_to("");
dt_dbus_destroy(darktable.dbus);
dt_control_shutdown(darktable.control);
dt_lib_cleanup(darktable.lib);
free(darktable.lib);
}
#ifdef USE_LUA
dt_lua_finalize();
#endif
dt_view_manager_cleanup(darktable.view_manager);
free(darktable.view_manager);
if(init_gui)
{
dt_imageio_cleanup(darktable.imageio);
free(darktable.imageio);
free(darktable.gui);
}
dt_image_cache_cleanup(darktable.image_cache);
free(darktable.image_cache);
dt_mipmap_cache_cleanup(darktable.mipmap_cache);
free(darktable.mipmap_cache);
if(init_gui)
{
dt_control_cleanup(darktable.control);
free(darktable.control);
dt_undo_cleanup(darktable.undo);
}
dt_colorspaces_cleanup(darktable.color_profiles);
dt_conf_cleanup(darktable.conf);
free(darktable.conf);
dt_points_cleanup(darktable.points);
free(darktable.points);
dt_iop_unload_modules_so();
dt_opencl_cleanup(darktable.opencl);
free(darktable.opencl);
#ifdef HAVE_GPHOTO2
dt_camctl_destroy((dt_camctl_t *)darktable.camctl);
#endif
dt_pwstorage_destroy(darktable.pwstorage);
#ifdef HAVE_GRAPHICSMAGICK
DestroyMagick();
#endif
dt_guides_cleanup(darktable.guides);
dt_database_destroy(darktable.db);
if(init_gui)
{
dt_bauhaus_cleanup();
}
dt_capabilities_cleanup();
dt_pthread_mutex_destroy(&(darktable.db_insert));
dt_pthread_mutex_destroy(&(darktable.plugin_threadsafe));
dt_pthread_mutex_destroy(&(darktable.capabilities_threadsafe));
dt_exif_cleanup();
}
~GmagickStaticInitializer() {
DestroyMagick();
}
int main (int argc, const char *argv[])
{
// option pre-scan
int quiet = 0;
int display = 0;
int i, j;
for(i = 1; i < argc; i++) {
const char *arg = argv[i];
if(arg[0] != '-' || !arg[1])
// first pass, skip images
num_images++;
else if(arg[1] != '-')
for(j = 1; arg[j]; j++) {
if(arg[j] == 'S') {
if(!arg[++j] && ++i >= argc)
/* FIXME parse check */
return(parse_config("", "-S"));
break;
}
switch(arg[j]) {
case 'h':
return(usage(0, NULL, NULL));
case 'q':
quiet = 1;
break;
case 'v':
zbar_increase_verbosity();
break;
case 'd':
display = 1;
break;
case 'D':
break;
default:
return(usage(1, "ERROR: unknown bundled option: -",
arg + j));
}
}
else if(!strcmp(arg, "--help"))
return(usage(0, NULL, NULL));
else if(!strcmp(arg, "--version")) {
printf("%s\n", PACKAGE_VERSION);
return(0);
}
else if(!strcmp(arg, "--quiet")) {
quiet = 1;
argv[i] = NULL;
}
else if(!strcmp(arg, "--verbose"))
zbar_increase_verbosity();
else if(!strncmp(arg, "--verbose=", 10))
zbar_set_verbosity(strtol(argv[i] + 10, NULL, 0));
else if(!strcmp(arg, "--display"))
display++;
else if(!strcmp(arg, "--nodisplay") ||
!strcmp(arg, "--set") ||
!strcmp(arg, "--xml") ||
!strcmp(arg, "--noxml") ||
!strcmp(arg, "--raw") ||
!strncmp(arg, "--set=", 6))
continue;
else if(!strcmp(arg, "--")) {
num_images += argc - i - 1;
break;
}
else
return(usage(1, "ERROR: unknown option: ", arg));
}
if(!num_images)
return(usage(1, "ERROR: specify image file(s) to scan", NULL));
num_images = 0;
InitializeMagick("zbarimg");
processor = zbar_processor_create(0);
assert(processor);
if(zbar_processor_init(processor, NULL, display)) {
zbar_processor_error_spew(processor, 0);
return(1);
}
for(i = 1; i < argc; i++) {
const char *arg = argv[i];
if(!arg)
continue;
if(arg[0] != '-' || !arg[1]) {
if(scan_image(arg))
return(exit_code);
}
else if(arg[1] != '-')
for(j = 1; arg[j]; j++) {
if(arg[j] == 'S') {
if((arg[++j])
? parse_config(arg + j, "-S")
: parse_config(argv[++i], "-S"))
return(1);
break;
}
switch(arg[j]) {
case 'd':
zbar_processor_set_visible(processor, 1);
break;
case 'D':
zbar_processor_set_visible(processor, 0);
break;
}
}
else if(!strcmp(arg, "--display"))
zbar_processor_set_visible(processor, 1);
else if(!strcmp(arg, "--nodisplay"))
zbar_processor_set_visible(processor, 0);
else if(!strcmp(arg, "--xml")) {
if(xmllvl < 1) {
xmllvl = 1;
#ifdef _WIN32
fflush(stdout);
_setmode(_fileno(stdout), _O_BINARY);
#endif
printf("%s", xml_head);
}
}
else if(!strcmp(arg, "--noxml") || !strcmp(arg, "--raw")) {
if(xmllvl > 0) {
xmllvl = 0;
printf("%s", xml_foot);
fflush(stdout);
#ifdef _WIN32
_setmode(_fileno(stdout), _O_TEXT);
#endif
}
if(!strcmp(arg, "--raw")) {
xmllvl = -1;
#ifdef _WIN32
fflush(stdout);
_setmode(_fileno(stdout), _O_BINARY);
#endif
}
}
else if(!strcmp(arg, "--set")) {
if(parse_config(argv[++i], "--set"))
return(1);
}
else if(!strncmp(arg, "--set=", 6)) {
if(parse_config(arg + 6, "--set="))
return(1);
}
else if(!strcmp(arg, "--"))
break;
}
for(i++; i < argc; i++)
if(scan_image(argv[i]))
return(exit_code);
/* ignore quit during last image */
if(exit_code == 3)
exit_code = 0;
if(xmllvl > 0) {
xmllvl = -1;
printf("%s", xml_foot);
fflush(stdout);
}
if(xmlbuf)
free(xmlbuf);
if(num_images && !quiet && xmllvl <= 0) {
fprintf(stderr, "scanned %d barcode symbols from %d images",
num_symbols, num_images);
#ifdef HAVE_SYS_TIMES_H
#ifdef HAVE_UNISTD_H
long clk_tck = sysconf(_SC_CLK_TCK);
struct tms tms;
if(clk_tck > 0 && times(&tms) >= 0) {
double secs = tms.tms_utime + tms.tms_stime;
secs /= clk_tck;
fprintf(stderr, " in %.2g seconds\n", secs);
}
#endif
#endif
fprintf(stderr, "\n");
if(notfound)
fprintf(stderr, "%s", warning_not_found);
}
if(num_images && notfound && !exit_code)
exit_code = 4;
zbar_processor_destroy(processor);
DestroyMagick();
return(exit_code);
}
int main(int argc, char **argv)
{
InitializeMagick("/");
#ifndef DEBUG
if (argc != 4) {
printf("\n************************************************************************\n");
printf("Please provide paramter and TWO file locations for image reconstruction!\n");
printf("For example: ./TissueReconstruction restacking file_name file_output \n");
printf("************************************************************************\n");
return 0;
}
else{
char *f_imagePath = strdup(argv[2]);
char *s_imagePath = strdup(argv[3]);
char *f_ptr, *s_ptr;
int ch = '/';
f_ptr = strrchr(f_imagePath, ch);
s_ptr = strrchr(s_imagePath, ch);
char *cht = "/";
if (f_ptr != cht || s_ptr != cht ) {
if(f_ptr != cht)
asprintf(&f_imagePath, "%s/", f_imagePath);
if(s_ptr != cht){
struct stat st = {0};
asprintf(&s_imagePath, "%s/Restacking/", s_imagePath);
if (stat(s_imagePath, &st) == -1)
mkdir(s_imagePath, 0700);
}
}
if (strcmp(argv[1], "processing") == 0)
image_processing(f_imagePath, s_imagePath);
else if (strcmp(argv[1], "restacking") == 0)
restacking(f_imagePath, 0, 1000, s_imagePath);
else if (strcmp(argv[1], "raw") == 0){
asprintf(&s_imagePath, "%stissue.raw\n", s_imagePath);
printf("Create a new RAW file in : %s\n", s_imagePath);
dumpStackIntoRawFile(f_imagePath, s_imagePath);
}
free(f_imagePath);
free(s_imagePath);
}
#endif
#ifdef DEBUG
/*
** image processing before restacking - max contrast, otsu-throsholding, cross correlation, image deconvolution
*/
//image_processing(FILE_PATH, FILE_MAX_OUTPUT);
//image_correction("/Users/adam/Documents/blockface_allbrains/3DOutput/y/", FILE_MAX_OUTPUT);
//image_processing("/Users/adam/Desktop/image/JPG_CROP/", "/Users/adam/Desktop/image/JPG_CROP_GRAY");
//check_raw(FILE_OUT_RAW);
/*
** restack images - Parameters:(source dir, start slide, end slide, output dir)
*/
//restacking(FILE_PATH,0, 1000, FILE_MAX_OUTPUT);
/*
** final - dump three planes to RAW file for Tissuestack used!
*/
//dumpStackIntoRawFile("/Users/adam/Desktop/image/Reconstruction/", FILE_OUT_RAW);
#endif
DestroyMagick();
return (0);
}
int tc_filter(frame_list_t *ptr_, char *options)
{
vframe_list_t *ptr = (vframe_list_t *)ptr_;
int instance = ptr->filter_id;
Image *pattern, *resized, *orig = 0;
ImageInfo *image_info;
PixelPacket *pixel_packet;
pixelsMask *pixel_last;
ExceptionInfo exception_info;
if(ptr->tag & TC_FILTER_GET_CONFIG) {
char buf[128];
optstr_filter_desc(options, MOD_NAME, MOD_CAP, MOD_VERSION,
MOD_AUTHOR, "VRYMO", "1");
tc_snprintf(buf, 128, "/dev/null");
optstr_param(options, "pattern", "Pattern image file path", "%s", buf);
tc_snprintf(buf, 128, "results.dat");
optstr_param(options, "results", "Results file path" , "%s", buf);
tc_snprintf(buf, 128, "%f", compare[instance]->delta);
optstr_param(options, "delta", "Delta error", "%f",buf,"0.0", "100.0");
return 0;
}
//----------------------------------
//
// filter init
//
//----------------------------------
if(ptr->tag & TC_FILTER_INIT)
{
unsigned int t,r,index;
pixelsMask *temp;
compare[instance] = tc_malloc(sizeof(compareData));
if(compare[instance] == NULL)
return (-1);
compare[instance]->vob = tc_get_vob();
if(compare[instance]->vob ==NULL)
return(-1);
compare[instance]->delta=DELTA_COLOR;
compare[instance]->step=1;
compare[instance]->width=0;
compare[instance]->height=0;
compare[instance]->frames = 0;
compare[instance]->pixel_mask = NULL;
pixel_last = NULL;
compare[instance]->width = compare[instance]->vob->ex_v_width;
compare[instance]->height = compare[instance]->vob->ex_v_height;
if (options != NULL) {
char pattern_name[PATH_MAX];
char results_name[PATH_MAX];
memset(pattern_name,0,PATH_MAX);
memset(results_name,0,PATH_MAX);
if(verbose) tc_log_info(MOD_NAME, "options=%s", options);
optstr_get(options, "pattern", "%[^:]", pattern_name);
optstr_get(options, "results", "%[^:]", results_name);
optstr_get(options, "delta", "%f", &compare[instance]->delta);
if (verbose > 1) {
tc_log_info(MOD_NAME, "Compare Image Settings:");
tc_log_info(MOD_NAME, " pattern = %s\n", pattern_name);
tc_log_info(MOD_NAME, " results = %s\n", results_name);
tc_log_info(MOD_NAME, " delta = %f\n", compare[instance]->delta);
}
if (strlen(results_name) == 0) {
// Ponemos el nombre del fichero al original con extension dat
strlcpy(results_name, "/tmp/compare.dat", sizeof(results_name));
}
if (!(compare[instance]->results = fopen(results_name, "w")))
{
tc_log_perror(MOD_NAME, "could not open file for writing");
}
InitializeMagick("");
if (verbose > 1)
tc_log_info(MOD_NAME, "Magick Initialized successfully");
GetExceptionInfo(&exception_info);
image_info = CloneImageInfo ((ImageInfo *) NULL);
strlcpy(image_info->filename, pattern_name, MaxTextExtent);
if (verbose > 1)
tc_log_info(MOD_NAME, "Trying to open image");
orig = ReadImage(image_info,
&exception_info);
if (orig == (Image *) NULL) {
MagickWarning(exception_info.severity,
exception_info.reason,
exception_info.description);
strlcpy(pattern_name, "/dev/null", sizeof(pattern_name));
}else{
if (verbose > 1)
tc_log_info(MOD_NAME, "Image loaded successfully");
}
}
else{
tc_log_perror(MOD_NAME, "Not image provided");
}
if (options != NULL)
if (optstr_lookup (options, "help")) {
help_optstr();
}
fprintf(compare[instance]->results,"#fps:%f\n",compare[instance]->vob->fps);
if (orig != NULL){
// Flip and resize
if (compare[instance]->vob->im_v_codec == CODEC_YUV)
TransformRGBImage(orig,YCbCrColorspace);
if (verbose > 1) tc_log_info(MOD_NAME, "Resizing the Image");
resized = ResizeImage(orig,
compare[instance]->width,
compare[instance]->height,
GaussianFilter,
1,
&exception_info);
if (verbose > 1)
tc_log_info(MOD_NAME, "Flipping the Image");
pattern = FlipImage(resized, &exception_info);
if (pattern == (Image *) NULL) {
MagickError (exception_info.severity,
exception_info.reason,
exception_info.description);
}
// Filling the matrix with the pixels values not
// alpha
if (verbose > 1) tc_log_info(MOD_NAME, "GetImagePixels");
pixel_packet = GetImagePixels(pattern,0,0,
pattern->columns,
pattern->rows);
if (verbose > 1) tc_log_info(MOD_NAME, "Filling the Image matrix");
for (t = 0; t < pattern->rows; t++)
for (r = 0; r < pattern->columns; r++){
index = t*pattern->columns + r;
if (pixel_packet[index].opacity == 0){
temp=tc_malloc(sizeof(struct pixelsMask));
temp->row=t;
temp->col=r;
temp->r = (uint8_t)ScaleQuantumToChar(pixel_packet[index].red);
temp->g = (uint8_t)ScaleQuantumToChar(pixel_packet[index].green);
temp->b = (uint8_t)ScaleQuantumToChar(pixel_packet[index].blue);
temp->next=NULL;
if (pixel_last == NULL){
pixel_last = temp;
compare[instance]->pixel_mask = temp;
}else{
pixel_last->next = temp;
pixel_last = temp;
}
}
}
if (verbose)
tc_log_info(MOD_NAME, "%s %s",
MOD_VERSION, MOD_CAP);
}
return(0);
}
//----------------------------------
//
// filter close
//
//----------------------------------
if(ptr->tag & TC_FILTER_CLOSE) {
if (compare[instance] != NULL) {
fclose(compare[instance]->results);
free(compare[instance]);
}
DestroyMagick();
compare[instance]=NULL;
return(0);
} /* filter close */
//----------------------------------
//
// filter frame routine
//
//----------------------------------
// tag variable indicates, if we are called before
// transcodes internal video/audio frame processing routines
// or after and determines video/audio context
if((ptr->tag & TC_POST_M_PROCESS) && (ptr->tag & TC_VIDEO)) {
// For now I only support RGB color space
pixelsMask *item = NULL;
double sr,sg,sb;
double avg_dr,avg_dg,avg_db;
if (compare[instance]->vob->im_v_codec == CODEC_RGB){
int r,g,b,c;
double width_long;
if (compare[instance]->pixel_mask != NULL)
{
item = compare[instance]->pixel_mask;
c = 0;
sr = 0.0;
sg = 0.0;
sb = 0.0;
width_long = compare[instance]->width*3;
while(item){
r = item->row*width_long + item->col*3;
g = item->row*width_long
+ item->col*3 + 1;
b = item->row*width_long
+ item->col*3 + 2;
// diff between points
// Interchange RGB values if necesary
sr = sr + (double)abs((unsigned char)ptr->video_buf[r] - item->r);
sg = sg + (double)abs((unsigned char)ptr->video_buf[g] - item->g);
sb = sb + (double)abs((unsigned char)ptr->video_buf[b] - item->b);
item = item->next;
c++;
}
avg_dr = sr/(double)c;
avg_dg = sg/(double)c;
avg_db = sb/(double)c;
if ((avg_dr < compare[instance]->delta) && (avg_dg < compare[instance]->delta) && (avg_db < compare[instance]->delta))
fprintf(compare[instance]->results,"1");
else
fprintf(compare[instance]->results,"n");
fflush(compare[instance]->results);
}
compare[instance]->frames++;
return(0);
}else{
// The colospace is YUV
// FIXME: Doesn't works, I need to code all this part
// again
int Y,Cr,Cb,c;
if (compare[instance]->pixel_mask != NULL)
{
item = compare[instance]->pixel_mask;
c = 0;
sr = 0.0;
sg = 0.0;
sb = 0.0;
while(item){
Y = item->row*compare[instance]->width + item->col;
Cb = compare[instance]->height*compare[instance]->width
+ (int)((item->row*compare[instance]->width + item->col)/4);
Cr = compare[instance]->height*compare[instance]->width
+ (int)((compare[instance]->height*compare[instance]->width)/4)
+ (int)((item->row*compare[instance]->width + item->col)/4);
// diff between points
// Interchange RGB values if necesary
sr = sr + (double)abs((unsigned char)ptr->video_buf[Y] - item->r);
sg = sg + (double)abs((unsigned char)ptr->video_buf[Cb] - item->g);
sb = sb + (double)abs((unsigned char)ptr->video_buf[Cr] - item->b);
item = item->next;
c++;
}
avg_dr = sr/(double)c;
avg_dg = sg/(double)c;
avg_db = sb/(double)c;
if ((avg_dr < compare[instance]->delta) && (avg_dg < compare[instance]->delta) && (avg_db < compare[instance]->delta))
fprintf(compare[instance]->results,"1");
else
fprintf(compare[instance]->results,"n");
}
compare[instance]->frames++;
return(0);
}
}
return(0);
}
/*----------------------------------------------------------
* int_imread:
* interface for imread function.
* should provide [RGB]=imread(name)
* [Index,Map]=imread(name) at Scilab level
*
* TO-DO
* - return on errors, even if exeption is NULL
*
* $Revision: 1.2 $ $Date: 2009-03-29 21:34:48 $
*----------------------------------------------------------*/
SipExport int
int_imread(char *fname)
{
/* Interface variables */
HyperMat *Img;
int m1, n1,l1, /* for name input argument */
m2, n2, /* for index output argument */
minlhs=1, maxlhs=2, minrhs=1, maxrhs=1, i;
double *l2;
/* Other variables */
unsigned long imgsize;
/* ImageMagick variables */
ExceptionInfo exception;
Image *image;
ImageInfo *image_info;
PixelPacket *pix;
ImageType imgtype;
bool stat;
CheckRhs(minrhs,maxrhs) ;
CheckLhs(minlhs,maxlhs) ;
/* Get name (#1) */
GetRhsVar(1, "c", &m1, &n1, &l1);
/* Initialize the image info structure and read an image. */
InitializeMagick(NULL);
GetExceptionInfo(&exception);
image_info=CloneImageInfo((ImageInfo *) NULL);
(void) strncpy(image_info->filename,cstk(l1),MaxTextExtent);
image=ReadImage(image_info,&exception);
if (image == (Image *) NULL) {
/* clean up */
if(exception.reason != NULL) {
char errmsg[50];
for (i=0; i<49; i++)
errmsg[i]=' ';
errmsg[49]='\0';
strncpy(errmsg,SipGetLocaleExceptionMessage(exception.severity,exception.reason),50);
DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
DestroyMagick();
sip_error(errmsg);
}
DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
DestroyMagick();
sip_error("unknown reason");
}
m2 = image->rows; n2 = image->columns;
if (sip_verbose == SIP_WORDY)
sciprint("Size:\t%ld rows X %ld columns\n\r", m2, n2);
imgsize = m2 * n2;
pix=GetImagePixels(image, 0, 0, n2, m2);
if(pix == (PixelPacket *) NULL)
SIP_MAGICK_ERROR;
switch(image->storage_class) {
case DirectClass: {
imgtype = GetImageType(image, &exception);
if(imgtype == BilevelType) {
stat = magick_binary_image_to_double_array(fname,pix,&l2, m2, n2);
if (!stat) return false;
CreateVarFromPtr(2, "d",&m2,&n2,&l2);
free(l2);
} else {
stat= magick_truecolor_image_to_double_hypermat(fname,pix,&Img,m2,n2);
if (!stat) return false;
CreateHMat(2,Img);
free_sci_tru_img(&Img);
}
m1 = n1 = 0;
CreateVar(3,"d",&m1,&n1,&l1);
break;
}
case PseudoClass: {
stat= magick_index_map_to_sci_dbl(fname,image,2);
if (!stat) return false;
break;
}
default:
sip_error("unknown color class");
break;
}
LhsVar(1) = 2;
LhsVar(2) = 3;
/* Terminate Imagemagick */
DestroyImageInfo(image_info);
DestroyImage(image);
DestroyExceptionInfo(&exception);
DestroyMagick();
return true;
}
int tc_filter(frame_list_t *ptr_, char *options)
{
vframe_list_t *ptr = (vframe_list_t *)ptr_;
vob_t *vob = NULL;
int instance = ptr->filter_id;
MyFilterData *mfd = mfd_all[instance];
if (mfd != NULL) {
vob = mfd->vob;
}
//----------------------------------
//
// filter init
//
//----------------------------------
if (ptr->tag & TC_FILTER_GET_CONFIG) {
optstr_filter_desc(options, MOD_NAME, MOD_CAP, MOD_VERSION, MOD_AUTHOR, "VRYO", "1");
// buf, name, comment, format, val, from, to
optstr_param(options, "file", "Image filename", "%s", "logo.png");
optstr_param(options, "posdef", "Position (0=None, 1=TopL, 2=TopR, 3=BotL, 4=BotR, 5=Center)", "%d", "0", "0", "5");
optstr_param(options, "pos", "Position (0-width x 0-height)", "%dx%d", "0x0", "0", "width", "0", "height");
optstr_param(options, "range", "Restrict rendering to framerange", "%u-%u", "0-0", "0", "oo", "0", "oo");
optstr_param(options, "fade", "Fade image in/out (# of frames)", "%u-%u", "0-0", "0", "oo", "0", "oo");
// bools
optstr_param(options, "ignoredelay", "Ignore delay specified in animations", "", "0");
optstr_param(options, "rgbswap", "Swap red/blue colors", "", "0");
optstr_param(options, "grayout", "YUV only: don't write Cb and Cr, makes a nice effect", "", "0");
optstr_param(options, "hqconv", "YUV only: do high quality rgb->yuv img conversion", "", "0");
optstr_param(options, "flip", "Mirror image", "", "0");
return 0;
}
if (ptr->tag & TC_FILTER_INIT) {
Image *timg;
Image *nimg;
ImageInfo *image_info;
ExceptionInfo exception_info;
int rgb_off = 0;
vob_t *tmpvob;
tmpvob = tc_get_vob();
if (tmpvob == NULL)
return -1;
mfd_all[instance] = tc_zalloc(sizeof(MyFilterData));
if (mfd_all[instance] == NULL)
return -1;
mfd = mfd_all[instance];
strlcpy(mfd->file, "logo.png", PATH_MAX);
mfd->end = (unsigned int)-1;
mfd->vob = tmpvob;
vob = mfd->vob;
if (options != NULL) {
if (verbose)
tc_log_info(MOD_NAME, "options=%s", options);
optstr_get(options, "file", "%[^:]", mfd->file);
optstr_get(options, "posdef", "%d", (int *)&mfd->pos);
optstr_get(options, "pos", "%dx%d", &mfd->posx, &mfd->posy);
optstr_get(options, "range", "%u-%u", &mfd->start, &mfd->end);
optstr_get(options, "fade", "%u-%u", &mfd->fadein, &mfd->fadeout);
if (optstr_lookup(options, "ignoredelay") != NULL)
mfd->ignoredelay = !mfd->ignoredelay;
if (optstr_lookup(options, "flip") != NULL)
mfd->flip = !mfd->flip;
if (optstr_lookup(options, "rgbswap") != NULL)
mfd->rgbswap = !mfd->rgbswap;
if (optstr_lookup(options, "grayout") != NULL)
mfd->grayout = !mfd->grayout;
if (optstr_lookup(options, "hqconv") != NULL)
mfd->hqconv = !mfd->hqconv;
if (optstr_lookup (options, "help") != NULL)
flogo_help_optstr();
}
if (verbose > 1) {
tc_log_info(MOD_NAME, " Logo renderer Settings:");
tc_log_info(MOD_NAME, " file = %s", mfd->file);
tc_log_info(MOD_NAME, " posdef = %d", mfd->pos);
tc_log_info(MOD_NAME, " pos = %dx%d", mfd->posx,
mfd->posy);
tc_log_info(MOD_NAME, " range = %u-%u", mfd->start,
mfd->end);
tc_log_info(MOD_NAME, " fade = %u-%u", mfd->fadein,
mfd->fadeout);
tc_log_info(MOD_NAME, " flip = %d", mfd->flip);
tc_log_info(MOD_NAME, " ignoredelay = %d", mfd->ignoredelay);
tc_log_info(MOD_NAME, " rgbswap = %d", mfd->rgbswap);
tc_log_info(MOD_NAME, " grayout = %d", mfd->grayout);
tc_log_info(MOD_NAME, " hqconv = %d", mfd->hqconv);
}
/* Transcode serializes module execution, so this does not need a
* semaphore.
*/
magick_usecount++;
if (!IsMagickInstantiated()) {
InitializeMagick("");
}
GetExceptionInfo(&exception_info);
image_info = CloneImageInfo((ImageInfo *) NULL);
strlcpy(image_info->filename, mfd->file, MaxTextExtent);
mfd->image = ReadImage(image_info, &exception_info);
if (mfd->image == (Image *) NULL) {
MagickWarning(exception_info.severity,
exception_info.reason,
exception_info.description);
strlcpy(mfd->file, "/dev/null", PATH_MAX);
return 0;
}
DestroyImageInfo(image_info);
if (mfd->image->columns > vob->ex_v_width
|| mfd->image->rows > vob->ex_v_height
) {
tc_log_error(MOD_NAME, "\"%s\" is too large", mfd->file);
return -1;
}
if (vob->im_v_codec == TC_CODEC_YUV420P) {
if ((mfd->image->columns & 1) || (mfd->image->rows & 1)) {
tc_log_error(MOD_NAME, "\"%s\" has odd sizes", mfd->file);
return -1;
}
}
mfd->images = (Image *)GetFirstImageInList(mfd->image);
nimg = NewImageList();
while (mfd->images != (Image *)NULL) {
if (mfd->flip || flip) {
timg = FlipImage(mfd->images, &exception_info);
if (timg == (Image *) NULL) {
MagickError(exception_info.severity,
exception_info.reason,
exception_info.description);
return -1;
}
AppendImageToList(&nimg, timg);
}
mfd->images = GetNextImageInList(mfd->images);
mfd->nr_of_images++;
}
// check for memleaks;
//DestroyImageList(image);
if (mfd->flip || flip) {
mfd->image = nimg;
}
/* initial delay. real delay = 1/100 sec * delay */
mfd->cur_delay = mfd->image->delay*vob->fps/100;
if (verbose & TC_DEBUG)
tc_log_info(MOD_NAME, "Nr: %d Delay: %d mfd->image->del %lu|",
mfd->nr_of_images, mfd->cur_delay, mfd->image->delay);
if (vob->im_v_codec == TC_CODEC_YUV420P) {
/* convert Magick RGB image format to YUV */
/* todo: convert the magick image if it's not rgb! (e.g. cmyk) */
Image *image;
uint8_t *yuv_hqbuf = NULL;
/* Round up for odd-size images */
unsigned long width = mfd->image->columns;
unsigned long height = mfd->image->rows;
int do_rgbswap = (rgbswap || mfd->rgbswap);
int i;
/* Allocate buffers for the YUV420P frames. mfd->nr_of_images
* will be 1 unless this is an animated GIF or MNG.
* This buffer needs to be large enough to store a temporary
* 24-bit RGB image (extracted from the ImageMagick handle).
*/
mfd->yuv = flogo_yuvbuf_alloc(width*height * 3, mfd->nr_of_images);
if (mfd->yuv == NULL) {
tc_log_error(MOD_NAME, "(%d) out of memory\n", __LINE__);
return -1;
}
if (mfd->hqconv) {
/* One temporary buffer, to hold full Y, U, and V planes. */
yuv_hqbuf = tc_malloc(width*height * 3);
if (yuv_hqbuf == NULL) {
tc_log_error(MOD_NAME, "(%d) out of memory\n", __LINE__);
return -1;
}
}
mfd->tcvhandle = tcv_init();
if (mfd->tcvhandle == NULL) {
tc_log_error(MOD_NAME, "image conversion init failed");
return -1;
}
image = GetFirstImageInList(mfd->image);
for (i = 0; i < mfd->nr_of_images; i++) {
if (!mfd->hqconv) {
flogo_convert_image(mfd->tcvhandle, image, mfd->yuv[i],
IMG_YUV420P, do_rgbswap);
} else {
flogo_convert_image(mfd->tcvhandle, image, yuv_hqbuf,
IMG_YUV444P, do_rgbswap);
// Copy over Y data from the 444 image
ac_memcpy(mfd->yuv[i], yuv_hqbuf, width * height);
// Resize U plane by 1/2 in each dimension, into the
// mfd YUV buffer
tcv_zoom(mfd->tcvhandle,
yuv_hqbuf + (width * height),
mfd->yuv[i] + (width * height),
width,
height,
1,
width / 2,
height / 2,
TCV_ZOOM_LANCZOS3
);
// Do the same with the V plane
tcv_zoom(mfd->tcvhandle,
yuv_hqbuf + 2*width*height,
mfd->yuv[i] + width*height + (width/2)*(height/2),
width,
height,
1,
width / 2,
height / 2,
TCV_ZOOM_LANCZOS3
);
}
image = GetNextImageInList(image);
}
if (mfd->hqconv)
tc_free(yuv_hqbuf);
tcv_free(mfd->tcvhandle);
} else {
/* for RGB format is origin bottom left */
/* for RGB, rgbswap is done in the frame routine */
rgb_off = vob->ex_v_height - mfd->image->rows;
mfd->posy = rgb_off - mfd->posy;
}
switch (mfd->pos) {
case NONE: /* 0 */
break;
case TOP_LEFT:
mfd->posx = 0;
mfd->posy = rgb_off;
break;
case TOP_RIGHT:
mfd->posx = vob->ex_v_width - mfd->image->columns;
break;
case BOT_LEFT:
mfd->posy = vob->ex_v_height - mfd->image->rows - rgb_off;
break;
case BOT_RIGHT:
mfd->posx = vob->ex_v_width - mfd->image->columns;
mfd->posy = vob->ex_v_height - mfd->image->rows - rgb_off;
break;
case CENTER:
mfd->posx = (vob->ex_v_width - mfd->image->columns)/2;
mfd->posy = (vob->ex_v_height- mfd->image->rows)/2;
/* align to not cause color disruption */
if (mfd->posx & 1)
mfd->posx++;
if (mfd->posy & 1)
mfd->posy++;
break;
}
if (mfd->posy < 0 || mfd->posx < 0
|| (mfd->posx + mfd->image->columns) > vob->ex_v_width
|| (mfd->posy + mfd->image->rows) > vob->ex_v_height) {
tc_log_error(MOD_NAME, "invalid position");
return -1;
}
/* for running through image sequence */
mfd->images = mfd->image;
/* Set up image/video coefficient lookup tables */
if (img_coeff_lookup[0] < 0) {
int i;
float maxrgbval = (float)MaxRGB; // from ImageMagick
for (i = 0; i <= MAX_UINT8_VAL; i++) {
float x = (float)ScaleCharToQuantum(i);
/* Alternatively:
* img_coeff = (maxrgbval - x) / maxrgbval;
* vid_coeff = x / maxrgbval;
*/
img_coeff_lookup[i] = 1.0 - (x / maxrgbval);
vid_coeff_lookup[i] = 1.0 - img_coeff_lookup[i];
}
}
// filter init ok.
if (verbose)
tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP);
return 0;
}
//----------------------------------
//
// filter close
//
//----------------------------------
if (ptr->tag & TC_FILTER_CLOSE) {
if (mfd) {
flogo_yuvbuf_free(mfd->yuv, mfd->nr_of_images);
mfd->yuv = NULL;
if (mfd->image) {
DestroyImage(mfd->image);
}
tc_free(mfd);
mfd = NULL;
mfd_all[instance] = NULL;
}
magick_usecount--;
if (magick_usecount == 0 && IsMagickInstantiated()) {
DestroyMagick();
}
return 0;
} /* filter close */
//----------------------------------
//
// filter frame routine
//
//----------------------------------
// tag variable indicates, if we are called before
// transcodes internal video/audo frame processing routines
// or after and determines video/audio context
if ((ptr->tag & TC_POST_M_PROCESS)
&& (ptr->tag & TC_VIDEO)
&& !(ptr->attributes & TC_FRAME_IS_SKIPPED)
) {
PixelPacket *pixel_packet;
uint8_t *video_buf;
int do_fade = 0;
float fade_coeff = 0.0;
float img_coeff, vid_coeff;
/* Note: ImageMagick defines opacity = 0 as fully visible, and
* opacity = MaxRGB as fully transparent.
*/
Quantum opacity;
int row, col;
if (ptr->id < mfd->start || ptr->id > mfd->end)
return 0;
if (strcmp(mfd->file, "/dev/null") == 0)
return 0;
if (ptr->id - mfd->start < mfd->fadein) {
// fading-in
fade_coeff = (float)(mfd->start - ptr->id + mfd->fadein) / (float)(mfd->fadein);
do_fade = 1;
} else if (mfd->end - ptr->id < mfd->fadeout) {
// fading-out
fade_coeff = (float)(ptr->id - mfd->end + mfd->fadeout) / (float)(mfd->fadeout);
do_fade = 1;
}
mfd->cur_delay--;
if (mfd->cur_delay < 0 || mfd->ignoredelay) {
int seq;
mfd->cur_seq = (mfd->cur_seq + 1) % mfd->nr_of_images;
mfd->images = mfd->image;
for (seq=0; seq<mfd->cur_seq; seq++)
mfd->images = mfd->images->next;
mfd->cur_delay = mfd->images->delay * vob->fps/100;
}
pixel_packet = GetImagePixels(mfd->images, 0, 0,
mfd->images->columns,
mfd->images->rows);
if (vob->im_v_codec == TC_CODEC_RGB24) {
unsigned long r_off, g_off, b_off;
if (!(rgbswap || mfd->rgbswap)) {
r_off = 0;
b_off = 2;
} else {
r_off = 2;
b_off = 0;
}
g_off = 1;
for (row = 0; row < mfd->image->rows; row++) {
video_buf = ptr->video_buf + 3 * ((row + mfd->posy) * vob->ex_v_width + mfd->posx);
for (col = 0; col < mfd->image->columns; col++) {
opacity = pixel_packet->opacity;
if (do_fade)
opacity += (Quantum)((MaxRGB - opacity) * fade_coeff);
if (opacity == 0) {
*(video_buf + r_off) = ScaleQuantumToChar(pixel_packet->red);
*(video_buf + g_off) = ScaleQuantumToChar(pixel_packet->green);
*(video_buf + b_off) = ScaleQuantumToChar(pixel_packet->blue);
} else if (opacity < MaxRGB) {
unsigned char opacity_uchar = ScaleQuantumToChar(opacity);
img_coeff = img_coeff_lookup[opacity_uchar];
vid_coeff = vid_coeff_lookup[opacity_uchar];
*(video_buf + r_off) = (uint8_t)((*(video_buf + r_off)) * vid_coeff)
+ (uint8_t)(ScaleQuantumToChar(pixel_packet->red) * img_coeff);
*(video_buf + g_off) = (uint8_t)((*(video_buf + g_off)) * vid_coeff)
+ (uint8_t)(ScaleQuantumToChar(pixel_packet->green) * img_coeff);
*(video_buf + b_off) = (uint8_t)((*(video_buf + b_off)) * vid_coeff)
+ (uint8_t)(ScaleQuantumToChar(pixel_packet->blue) * img_coeff);
}
video_buf += 3;
pixel_packet++;
}
}
} else { /* !RGB */
unsigned long vid_size = vob->ex_v_width * vob->ex_v_height;
unsigned long img_size = mfd->images->columns * mfd->images->rows;
uint8_t *img_pixel_Y, *img_pixel_U, *img_pixel_V;
uint8_t *vid_pixel_Y, *vid_pixel_U, *vid_pixel_V;
img_pixel_Y = mfd->yuv[mfd->cur_seq];
img_pixel_U = img_pixel_Y + img_size;
img_pixel_V = img_pixel_U + img_size/4;
for (row = 0; row < mfd->images->rows; row++) {
vid_pixel_Y = ptr->video_buf + (row + mfd->posy)*mfd->vob->ex_v_width + mfd->posx;
vid_pixel_U = ptr->video_buf + vid_size + (row/2 + mfd->posy/2)*(mfd->vob->ex_v_width/2) + mfd->posx/2;
vid_pixel_V = vid_pixel_U + vid_size/4;
for (col = 0; col < mfd->images->columns; col++) {
int do_UV_pixels = (mfd->grayout == 0 && !(row % 2) && !(col % 2)) ? 1 : 0;
opacity = pixel_packet->opacity;
if (do_fade)
opacity += (Quantum)((MaxRGB - opacity) * fade_coeff);
if (opacity == 0) {
*vid_pixel_Y = *img_pixel_Y;
if (do_UV_pixels) {
*vid_pixel_U = *img_pixel_U;
*vid_pixel_V = *img_pixel_V;
}
} else if (opacity < MaxRGB) {
unsigned char opacity_uchar = ScaleQuantumToChar(opacity);
img_coeff = img_coeff_lookup[opacity_uchar];
vid_coeff = vid_coeff_lookup[opacity_uchar];
*vid_pixel_Y = (uint8_t)(*vid_pixel_Y * vid_coeff) + (uint8_t)(*img_pixel_Y * img_coeff);
if (do_UV_pixels) {
*vid_pixel_U = (uint8_t)(*vid_pixel_U * vid_coeff) + (uint8_t)(*img_pixel_U * img_coeff);
*vid_pixel_V = (uint8_t)(*vid_pixel_V * vid_coeff) + (uint8_t)(*img_pixel_V * img_coeff);
}
}
vid_pixel_Y++;
img_pixel_Y++;
if (do_UV_pixels) {
vid_pixel_U++;
img_pixel_U++;
vid_pixel_V++;
img_pixel_V++;
}
pixel_packet++;
}
}
}
}
return 0;
}
int tc_filter(frame_list_t *ptr_, char *options)
{
vframe_list_t *ptr = (vframe_list_t *)ptr_;
int instance=ptr->filter_id;
//----------------------------------
//
// filter get config
//
//----------------------------------
if(ptr->tag & TC_FILTER_GET_CONFIG && options) {
char buf[255];
optstr_filter_desc (options, MOD_NAME, MOD_CAP, MOD_VERSION, MOD_AUTHOR, "VRYOM", "1");
tc_snprintf (buf, sizeof(buf), "%u-%u", data[instance]->start, data[instance]->end);
optstr_param (options, "range", "Frame Range", "%d-%d", buf, "0", "oo", "0", "oo");
tc_snprintf (buf, sizeof(buf), "%dx%d", data[instance]->xpos, data[instance]->ypos);
optstr_param (options, "pos", "Position of logo", "%dx%d", buf, "0", "width", "0", "height");
tc_snprintf (buf, sizeof(buf), "%dx%d", data[instance]->width, data[instance]->height);
optstr_param (options, "size", "Size of logo", "%dx%d", buf, "0", "width", "0", "height");
tc_snprintf (buf, sizeof(buf), "%d", data[instance]->mode);
optstr_param (options, "mode", "Filter Mode (0=none,1=solid,2=xy,3=shape)", "%d", buf, "0", "3");
tc_snprintf (buf, sizeof(buf), "%d", data[instance]->border);
optstr_param (options, "border", "Visible Border", "", buf);
tc_snprintf (buf, sizeof(buf), "%d", data[instance]->dump);
optstr_param (options, "dump", "Dump filterarea to file", "", buf);
tc_snprintf (buf, sizeof(buf), "%d", data[instance]->xweight);
optstr_param (options, "xweight","X-Y Weight(0%-100%)", "%d", buf, "0", "100");
tc_snprintf (buf, sizeof(buf), "%x%x%x", data[instance]->rcolor, data[instance]->gcolor, data[instance]->bcolor);
optstr_param (options, "fill", "Solid Fill Color(RGB)", "%2x%2x%2x", buf, "00", "FF", "00", "FF", "00", "FF");
tc_snprintf (buf, sizeof(buf), "%s", data[instance]->file);
optstr_param (options, "file", "Image with alpha/shape information", "%s", buf);
return 0;
}
//----------------------------------
//
// filter init
//
//----------------------------------
if(ptr->tag & TC_FILTER_INIT) {
if((vob = tc_get_vob())==NULL) return(-1);
if((data[instance] = tc_malloc (sizeof(logoaway_data))) == NULL) {
tc_log_error(MOD_NAME, "can't allocate filter data");
return (-1);
}
data[instance]->start = 0;
data[instance]->end = (unsigned int)-1;
data[instance]->xpos = -1;
data[instance]->ypos = -1;
data[instance]->width = -1;
data[instance]->height = -1;
data[instance]->mode = 0;
data[instance]->border = 0;
data[instance]->xweight = 50;
data[instance]->yweight = 50;
data[instance]->rcolor = 0;
data[instance]->gcolor = 0;
data[instance]->bcolor = 0;
data[instance]->ycolor = 16;
data[instance]->ucolor = 128;
data[instance]->vcolor = 128;
data[instance]->alpha = 0;
data[instance]->dump = 0;
// filter init ok.
if(verbose) tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP);
if(options!=NULL) {
optstr_get (options, "range", "%d-%d", &data[instance]->start, &data[instance]->end);
optstr_get (options, "pos", "%dx%d", &data[instance]->xpos, &data[instance]->ypos);
optstr_get (options, "size", "%dx%d", &data[instance]->width, &data[instance]->height);
data[instance]->width += data[instance]->xpos; data[instance]->height += data[instance]->ypos;
optstr_get (options, "mode", "%d", &data[instance]->mode);
if (optstr_lookup (options, "border") != NULL)
data[instance]->border = 1;
if (optstr_lookup (options, "help") != NULL)
help_optstr();
optstr_get (options, "xweight", "%d", &data[instance]->xweight);
data[instance]->yweight = 100 - data[instance]->xweight;
optstr_get (options, "fill", "%2x%2x%2x", &data[instance]->rcolor, &data[instance]->gcolor, &data[instance]->bcolor);
data[instance]->ycolor = (0.257 * data[instance]->rcolor) + (0.504 * data[instance]->gcolor) + (0.098 * data[instance]->bcolor) + 16;
data[instance]->ucolor = (0.439 * data[instance]->rcolor) - (0.368 * data[instance]->gcolor) - (0.071 * data[instance]->bcolor) + 128;
data[instance]->vcolor = -(0.148 * data[instance]->rcolor) - (0.291 * data[instance]->gcolor) + (0.439 * data[instance]->bcolor) + 128;
if (optstr_get (options, "file", "%[^:]", data[instance]->file) >= 0)
data[instance]->alpha = 1;
if (optstr_lookup (options, "dump") != NULL)
data[instance]->dump = 1;
}
if(verbose) tc_log_info(MOD_NAME, "instance(%d) options=%s", instance, options);
if(verbose > 1) {
tc_log_info (MOD_NAME, " LogoAway Filter Settings:");
tc_log_info (MOD_NAME, " pos = %dx%d", data[instance]->xpos, data[instance]->ypos);
tc_log_info (MOD_NAME, " size = %dx%d", data[instance]->width-data[instance]->xpos, data[instance]->height-data[instance]->ypos);
tc_log_info (MOD_NAME, " mode = %d(%s)", data[instance]->mode, modes[data[instance]->mode]);
tc_log_info (MOD_NAME, " border = %d", data[instance]->border);
tc_log_info (MOD_NAME, " x-y weight = %d:%d", data[instance]->xweight, data[instance]->yweight);
tc_log_info (MOD_NAME, " fill color = %2X%2X%2X", data[instance]->rcolor, data[instance]->gcolor, data[instance]->bcolor);
if(data[instance]->alpha)
tc_log_info (MOD_NAME, " file = %s", data[instance]->file);
if(data[instance]->dump)
tc_log_info (MOD_NAME, " dump = %d", data[instance]->dump);
}
if( (data[instance]->xpos > vob->im_v_width) || (data[instance]->ypos > vob->im_v_height) || (data[instance]->xpos < 0) || (data[instance]->ypos < 0) ) {
tc_log_error(MOD_NAME, "invalid position");
return(-1);
}
if( (data[instance]->width > vob->im_v_width) || (data[instance]->height > vob->im_v_height) || (data[instance]->width-data[instance]->xpos < 0) || (data[instance]->height-data[instance]->ypos < 0) ) {
tc_log_error(MOD_NAME, "invalid size");
return(-1);
}
if( (data[instance]->xweight > 100) || (data[instance]->xweight < 0) ) {
tc_log_error(MOD_NAME, "invalid x weight");
return(-1);
}
if( (data[instance]->mode < 0) || (data[instance]->mode > 3) ) {
tc_log_error(MOD_NAME, "invalid mode");
return(-1);
}
if( (data[instance]->mode == 3) && (data[instance]->alpha == 0) ) {
tc_log_error(MOD_NAME, "alpha/shape file needed for SHAPE-mode");
return(-1);
}
if((data[instance]->alpha) || (data[instance]->dump)) {
InitializeMagick("");
GetExceptionInfo(&data[instance]->exception_info);
if(data[instance]->alpha) {
data[instance]->image_info = CloneImageInfo((ImageInfo *) NULL);
strlcpy(data[instance]->image_info->filename, data[instance]->file, MaxTextExtent);
data[instance]->image = ReadImage(data[instance]->image_info, &data[instance]->exception_info);
if (data[instance]->image == (Image *) NULL) {
tc_log_error(MOD_NAME, "\n");
MagickWarning (data[instance]->exception_info.severity, data[instance]->exception_info.reason, data[instance]->exception_info.description);
return(-1);
}
if ((data[instance]->image->columns != (data[instance]->width-data[instance]->xpos)) || (data[instance]->image->rows != (data[instance]->height-data[instance]->ypos))) {
tc_log_error(MOD_NAME, "\"%s\" has incorrect size", data[instance]->file);
return(-1);
}
data[instance]->pixel_packet = GetImagePixels(data[instance]->image, 0, 0, data[instance]->image->columns, data[instance]->image->rows);
}
if(data[instance]->dump) {
if((data[instance]->dump_buf = tc_malloc ((data[instance]->width-data[instance]->xpos)*(data[instance]->height-data[instance]->ypos)*3)) == NULL)
tc_log_error(MOD_NAME, "out of memory");
data[instance]->dumpimage_info = CloneImageInfo((ImageInfo *) NULL);
}
}
return(0);
}
//----------------------------------
//
// filter close
//
//----------------------------------
if(ptr->tag & TC_FILTER_CLOSE) {
if (data[instance]->image != (Image *)NULL) {
DestroyImage(data[instance]->image);
DestroyImageInfo(data[instance]->image_info);
}
if (data[instance]->dumpimage != (Image *)NULL) {
DestroyImage(data[instance]->dumpimage);
DestroyImageInfo(data[instance]->dumpimage_info);
DestroyConstitute();
}
DestroyExceptionInfo(&data[instance]->exception_info);
DestroyMagick();
if(data[instance]->dump_buf) free(data[instance]->dump_buf);
if(data[instance]) free(data[instance]);
data[instance] = NULL;
return(0);
}
//----------------------------------
//
// filter frame routine
//
//----------------------------------
if(ptr->tag & TC_PRE_M_PROCESS && ptr->tag & TC_VIDEO && !(ptr->attributes & TC_FRAME_IS_SKIPPED)) {
if (ptr->id < data[instance]->start || ptr->id > data[instance]->end) return (0);
if(vob->im_v_codec==TC_CODEC_RGB24) {
work_with_rgb_frame(ptr->video_buf, vob->im_v_width, vob->im_v_height, instance);
} else {
work_with_yuv_frame(ptr->video_buf, vob->im_v_width, vob->im_v_height, instance);
}
}
return(0);
}
void
imageproc::shutdown()
{
DestroyMagick();
}
int main(int argc, char **argv)
{
ExceptionInfo exception;
ImageInfo *image_info;
Image *image;
char *ext;
char image_name[NAME_MAX + 1];
char deepzoom_directory[NAME_MAX + 1];
char dzi[NAME_MAX];
int opt;
while ((opt = getopt(argc, argv, "t:o:h")) != -1) {
switch (opt) {
case 't':
tile_sz = atoi(optarg);
break;
case 'o':
overlap = atoi(optarg);
break;
case 'h':
print_usage();
exit(EXIT_SUCCESS);
}
}
if (optind < argc) {
snprintf(image_name, sizeof(image_name), "%s", argv[optind]);
} else {
print_usage();
exit(EXIT_FAILURE);
}
InitializeMagick(NULL);
GetExceptionInfo(&exception);
image_info = CloneImageInfo((ImageInfo *)NULL);
snprintf(image_info->filename, sizeof(image_info->filename), "%s",
image_name);
image = ReadImage(image_info, &exception);
if (exception.severity != UndefinedException)
CatchImageException(image);
ext = rindex(image_name, '.');
snprintf(deepzoom_directory, strlen(image_name) - strlen(ext) + 1,
"%s", image_name);
strcpy(dzi, deepzoom_directory);
strncat(deepzoom_directory, "_files",
NAME_MAX - strlen(deepzoom_directory));
printf("Creating directory: %s\n", deepzoom_directory);
mkdir(deepzoom_directory, 0777);
chdir(deepzoom_directory);
create_levels(image, ext + 1, image->columns, image->rows);
chdir("..");
strncat(dzi, ".dzi", NAME_MAX - strlen(dzi));
printf("Writing DZI: %s\n", dzi);
write_dzi(dzi, ext + 1, image->columns, image->rows);
DestroyImage(image);
DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
DestroyMagick();
exit(EXIT_SUCCESS);
}
/*----------------------------------------------------------
* int_imfinfo:
* interface for imfinfo function.
* should provide type=imfinfo(name) at Scilab level
* $Revision: 1.3 $ $Date: 2009-04-14 14:02:45 $
*----------------------------------------------------------*/
SipExport int
int_imfinfo(char *fname)
{
/* Interface variables */
int mC, nC, lC, /* for name input arg */
mV, nV, lV, /* for "verbose" optional input arg */
mL=12, nL=1, lL, /* for list output arg */
mS=1, nS=12,
mFileName, nFileName=1,
mFileSize=1, nFileSize=1,
mFormat, nFormat=1,
mWidth=1, nWidth=1,
mHeight=1, nHeight=1,
mDepth=1, nDepth=1,
mStorageType, nStorageType=1,
mNumberOfColors=1, nNumberOfColors=1,
mResolutionUnit, nResolutionUnit=1,
mXResolution=1, nXResolution=1,
mYResolution=1, nYResolution=1,
pos,
minlhs=1, maxlhs=1, minrhs=1, maxrhs=2, i;
unsigned long int *lWidth, *lHeight, *lDepth, *lNumberOfColors,
*lFileSize, fsize;
char *lFileName, *lStorageType, *lFormat, *lResolutionUnit, *arg2;
double *lXResolution, *lYResolution;
static char
*Str[]= { "type", "FileName", "FileSize", "Format",
"Width", "Height", "Depth", "StorageType",
"NumberOfColors", "ResolutionUnit", "XResolution",
"YResolution" };
/* ImageMagick variables */
ExceptionInfo exception;
Image *image;
ImageInfo *image_info;
CheckRhs(minrhs, maxrhs);
CheckLhs(minlhs, maxlhs);
/* Get name (#1) and "verbose" optional arg (#2)*/
GetRhsVar(1, "c", &mC, &nC, &lC);
if (Rhs == 2) {
GetRhsVar(2, "c", &mV, &nV, &lV);
arg2 = (char *)calloc(strlen(cstk(lV))+1, sizeof(char));
if (!arg2)
sip_error("unable to alloc memory");
strcpy(arg2,cstk(lV));
}
InitializeMagick(NULL);
GetExceptionInfo(&exception);
image_info=CloneImageInfo((ImageInfo *) NULL);
(void) strcpy(image_info->filename,cstk(lC));
image = PingImage(image_info, &exception);
if (image == (Image *) NULL) {
/* clean up */
if (Rhs==2)
free(arg2);
if(exception.reason != NULL) {
char errmsg[50];
for (i=0; i<49; i++)
errmsg[i]=' ';
errmsg[49]='\0';
strncpy(errmsg,GetLocaleExceptionMessage(exception.severity,exception.reason),50);
DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
DestroyMagick();
sip_error(errmsg);
}
DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
DestroyMagick();
sip_error("unknown reason");
}
pos =1;
CreateVar(1, "t", &mL, &nL, &lL);
CreateListVarFromPtr(1,pos++,"S", &mS, &nS, Str);
lFileName = image->filename;
mFileName = strlen(image->filename);
CreateListVarFromPtr(1,pos++,"c", &mFileName, &nFileName, &lFileName);
fsize = SizeBlob(image);
lFileSize = &fsize;
CreateListVarFromPtr(1,pos++,"i", &mFileSize, &nFileSize, &lFileSize);
lFormat = image->magick;
mFormat = strlen(image->magick);
CreateListVarFromPtr(1,pos++,"c", &mFormat, &nFormat, &lFormat);
lWidth = &(image->columns);
CreateListVarFromPtr(1,pos++,"i", &mWidth, &nWidth, &lWidth);
lHeight = &(image->rows);
CreateListVarFromPtr(1,pos++,"i", &mHeight, &nHeight, &lHeight);
lDepth = &(image->depth);
CreateListVarFromPtr(1,pos++,"i", &mDepth, &nDepth, &lDepth);
lStorageType = (image->storage_class == DirectClass)? "truecolor":"indexed";
mStorageType = strlen(lStorageType);
CreateListVarFromPtr(1,pos++,"c", &mStorageType, &nStorageType, &lStorageType);
lNumberOfColors = &(image->colors);
CreateListVarFromPtr(1,pos++,"i", &mNumberOfColors, \
&nNumberOfColors, &lNumberOfColors);
/*
lComments = image->comments;
mComments = strlen(image->comments);
CreateListVarFromPtr(1,pos++,"c", &mComments, &nComments, &lComments);
*/
lResolutionUnit = (image->units == PixelsPerInchResolution)?"inch":"centimeter";
mResolutionUnit = strlen(lResolutionUnit);
CreateListVarFromPtr(1,pos++,"c", &mResolutionUnit, \
&nResolutionUnit, &lResolutionUnit);
lXResolution = &(image->x_resolution);
CreateListVarFromPtr(1,pos++,"i", &mXResolution, &nXResolution, &lXResolution);
lYResolution = &(image->y_resolution);
CreateListVarFromPtr(1,pos++,"i", &mYResolution, &nYResolution, &lYResolution);
if (Rhs==2) {
if (strcmp(arg2,"verbose") != 0)
sip_error("invalid 2nd argument");
sciprint(" FileName: %s\n\r", image->filename);
sciprint(" FileSize: %d\n\r", fsize);
sciprint(" Format: %s\n\r", image->magick);
sciprint(" Width: %d\n\r", image->columns);
sciprint(" Height: %d\n\r", image->rows);
sciprint(" Depth: %d\n\r", image->depth);
sciprint(" StorageType: %s\n\r", lStorageType);
sciprint(" NumberOfColors: %d\n\r", image->colors);
sciprint(" ResolutionUnit: %s\n\r", lResolutionUnit);
sciprint(" XResolution: %f\n\r", image->x_resolution);
sciprint(" YResolution: %f\n\r", image->y_resolution);
free(arg2);
}
/* Terminate Imagemagick */
DestroyImageInfo(image_info);
DestroyImage(image);
DestroyExceptionInfo(&exception);
DestroyMagick();
/* Return variables */
LhsVar(1) = 1;
return true;
}
void dt_cleanup()
{
const int init_gui = (darktable.gui != NULL);
#ifdef USE_LUA
dt_lua_finalize();
#endif
if(init_gui)
{
dt_ctl_switch_mode_to(DT_MODE_NONE);
dt_dbus_destroy(darktable.dbus);
dt_control_write_config(darktable.control);
dt_control_shutdown(darktable.control);
dt_lib_cleanup(darktable.lib);
free(darktable.lib);
}
dt_view_manager_cleanup(darktable.view_manager);
free(darktable.view_manager);
if(init_gui)
{
dt_imageio_cleanup(darktable.imageio);
free(darktable.imageio);
dt_gui_gtk_cleanup(darktable.gui);
free(darktable.gui);
}
dt_image_cache_cleanup(darktable.image_cache);
free(darktable.image_cache);
dt_mipmap_cache_cleanup(darktable.mipmap_cache);
free(darktable.mipmap_cache);
if(init_gui)
{
dt_control_cleanup(darktable.control);
free(darktable.control);
dt_undo_cleanup(darktable.undo);
}
dt_conf_cleanup(darktable.conf);
free(darktable.conf);
dt_points_cleanup(darktable.points);
free(darktable.points);
dt_iop_unload_modules_so();
dt_opencl_cleanup(darktable.opencl);
free(darktable.opencl);
#ifdef HAVE_GPHOTO2
dt_camctl_destroy(darktable.camctl);
#endif
dt_pwstorage_destroy(darktable.pwstorage);
dt_fswatch_destroy(darktable.fswatch);
#ifdef HAVE_GRAPHICSMAGICK
DestroyMagick();
#endif
dt_database_destroy(darktable.db);
dt_bauhaus_cleanup();
dt_capabilities_cleanup();
dt_pthread_mutex_destroy(&(darktable.db_insert));
dt_pthread_mutex_destroy(&(darktable.plugin_threadsafe));
dt_pthread_mutex_destroy(&(darktable.capabilities_threadsafe));
dt_exif_cleanup();
#ifdef HAVE_GEGL
gegl_exit();
#endif
}
int main(int argc, char *argv[]) {
char *original_image_path;
char rendition_spec[MaxTextExtent] = {0};
int is_rendition_generated = 0;
int return_code = 0;
int image_magick_started = 0;
char opt;
char const* usage =
"Usage: %s <original_image_path> -f <crop_width>x<crop_height>+<crop_x>+<crop_y>+<resize_width>x<resize_height>+<resize_method>+<blur>+<quality>+<progressive> -o <output> [-f ... -o ...]\n"
"normally, use 0 for resize_method, and 1 for blur.\n"
"progressive 80%% compression 0.5 blur 300x200 thumbnail: -f 2592x1728+0+311+300x200+0+0.5+80+1\n"
"non progressive 70%% compression 1.0 blur 300x200 thumbnail: -f 2592x1728+0+311+300x200+0+1+70+0\n"
;
Image *original_image;
Image *rendition;
ImageInfo *image_info;
ExceptionInfo exception;
if (argc < 2) {
fprintf(stderr, "Need input image path\n");
fprintf(stderr, usage, argv[0]);
return -1;
}
original_image_path = argv[1];
/* start image magick */
InitializeMagick(*argv);
GetExceptionInfo(&exception);
image_info = CloneImageInfo((ImageInfo*) NULL);
image_magick_started = 1;
/* load original */
strncpy(image_info->filename, original_image_path, MaxTextExtent);
image_info->filename[MaxTextExtent-1] = '\0';
original_image = ReadImage(image_info, &exception);
if (!original_image) {
CatchException(&exception);
fprintf(stderr, "%s\n", exception.reason);
return_code = -1;
goto CLEANUP;
}
printf("Loaded: %s\n", original_image_path);
optind = 2;
while ((opt = getopt(argc, argv, "f:o:")) != -1) {
switch (opt) {
case 'o':
if (!generate_rendition(original_image, image_info, rendition_spec, optarg, &exception)) {
fprintf(stderr, "%s : during %s -> %s (%s)\n", exception.reason, original_image_path, rendition_spec, optarg);
}
break;
case 'f':
strncpy(rendition_spec, optarg, MaxTextExtent);
break;
default:
fprintf(stderr, usage, argv[0]);
return -1;
}
}
CLEANUP:
if (!image_magick_started) {
goto RETURN;
}
DestroyImageInfo(image_info);
DestroyExceptionInfo(&exception);
DestroyMagick();
RETURN:
return return_code;
}
