program/psiconv/gen_image.c

/*
 * gen_image.c - Part of psiconv, a PSION 5 file formats converter
 * Copyright (c) 1999  Frodo Looijaard <frodol@dds.nl>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "config.h"
#include "data.h"
#include "gen.h"
#include <string.h>
#include "psiconv.h"

#if IMAGEMAGICK
#include <magick/magick.h>

/* This is ridiculously simple using ImageMagick. Without it, it would
   be quite somewhat harder - it will be left for later on.
   Note that we ignore any errors. Dangerous... */

static Image *get_paint_data_section(psiconv_paint_data_section sec)
{
  Image *image;
  float *pixel, *p, *red, *green, *blue;
  int x,y;
  ExceptionInfo *exc;

  GetExceptionInfo(exc);
  red = sec->red;
  green = sec->green;
  blue = sec->blue;
  p = pixel = malloc(sec->xsize * sec->ysize * 3 * sizeof(float));
  for (y = 0; y < sec->ysize; y++) {
    for (x = 0; x < sec->xsize; x++) {
      *p++ = *red++;
      *p++ = *green++;
      *p++ = *blue++;
    }
  }
  image = ConstituteImage(sec->xsize,sec->ysize,"RGB",FloatPixel,pixel,exc);
  free(pixel);
  DestroyExceptionInfo(exc);

  return image;
}

#endif

static int psiconv_gen_image_clipart(FILE *of, psiconv_clipart_f f, 
                                     const char *dest)
{
#if IMAGEMAGICK
  psiconv_clipart_section section;
  MagickInfo *mi = GetMagickInfo(dest);
  ImageInfo image_info;
  Image *image = NULL;
  Image *last_image = NULL;
  Image *this_image;
  int i;
  
  if ((psiconv_list_length(f->sections) < 1) || 
      ((psiconv_list_length(f->sections)) > 1 && ! (mi->adjoin)))
#endif
    return -1;
#if IMAGEMAGICK
  for (i = 0; i < psiconv_list_length(f->sections); i++) {
    section = psiconv_list_get(f->sections,i);
    this_image = get_paint_data_section(section->picture);
    if (! image) {
      image = this_image;
      last_image = image;
    } else {
      last_image->next=this_image;
      this_image->previous=last_image;
      this_image->scene=i;
      last_image=this_image;
    }
  }

  GetImageInfo(&image_info);
  image_info.file = of; 
  strcpy(image->magick, dest);
  image_info.adjoin=1;
  WriteImage(&image_info,image);
  return 0;
#endif
}

static int psiconv_gen_image_mbm(FILE *of, psiconv_mbm_f f, const char *dest)
{
#if IMAGEMAGICK
  psiconv_paint_data_section section;
  MagickInfo *mi = GetMagickInfo(dest);
  ImageInfo image_info;
  Image *image = NULL;
  Image *last_image = NULL;
  Image *this_image;
  int i;
  
  if ((psiconv_list_length(f->sections) < 1) || 
      ((psiconv_list_length(f->sections)) > 1 && ! (mi->adjoin)))
#endif
    return -1;
#if IMAGEMAGICK
  for (i = 0; i < psiconv_list_length(f->sections); i++) {
    section = psiconv_list_get(f->sections,i);
    this_image = get_paint_data_section(section);
    if (! image) {
      image = this_image;
      last_image = image;
    } else {
      last_image->next=this_image;
      this_image->previous=last_image;
      this_image->scene=i;
      last_image=this_image;
    }
  }

  GetImageInfo(&image_info);
  image_info.file = of; 
  strcpy(image->magick, dest);
  image_info.adjoin=1;
  WriteImage(&image_info,image);
  return 0;
#endif
}

static void psiconv_gen_image_sketch(FILE *of, psiconv_sketch_f f,
                                     const char *dest)
{
#if IMAGEMAGICK
  ImageInfo image_info;
  Image *image;
 
  image = get_paint_data_section(f->sketch_sec->picture);
  GetImageInfo(&image_info);
  image_info.file = of; 
  strcpy(image->magick, dest);
  WriteImage(&image_info,image);
#endif
}

static int psiconv_gen_image(FILE * of, const psiconv_file file, 
                             const char *dest)
{
  if (file->type == psiconv_mbm_file) 
    return psiconv_gen_image_mbm(of,(psiconv_mbm_f) file->file,dest);
  if (file->type == psiconv_clipart_file) 
    return psiconv_gen_image_clipart(of,(psiconv_clipart_f) file->file,dest);
  else if (file->type == psiconv_sketch_file) {
    psiconv_gen_image_sketch(of,(psiconv_sketch_f) file->file,dest);
    return 0;
  } else
    return -1;
}

void init_image(void)
{
  struct psiconv_fileformat ff;
#if IMAGEMAGICK
  MagickInfo *mi;
  ff.output = psiconv_gen_image;
  for (mi = GetMagickInfo(NULL); mi ; mi = mi->next) {
    if (mi->encoder) {
      ff.name = strdup(mi->tag);
      ff.description = strdup(mi->description);
      psiconv_list_add(fileformat_list,&ff);
    }
  }
#endif
}

1	frodo	32	/*
2			* gen_image.c - Part of psiconv, a PSION 5 file formats converter
3			* Copyright (c) 1999 Frodo Looijaard <frodol@dds.nl>
4			*
5			* This program is free software; you can redistribute it and/or modify
6			* it under the terms of the GNU General Public License as published by
7			* the Free Software Foundation; either version 2 of the License, or
8			* (at your option) any later version.
9			*
10			* This program is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU General Public License for more details.
14			*
15			* You should have received a copy of the GNU General Public License
16			* along with this program; if not, write to the Free Software
17			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18			*/
19
20			#include "config.h"
21			#include "data.h"
22			#include "gen.h"
23			#include <string.h>
24	frodo	34	#include "psiconv.h"
25	frodo	32
26			#if IMAGEMAGICK
27			#include <magick/magick.h>
28
29			/* This is ridiculously simple using ImageMagick. Without it, it would
30	frodo	49	be quite somewhat harder - it will be left for later on.
31			Note that we ignore any errors. Dangerous... */
32	frodo	32
33	frodo	39	static Image *get_paint_data_section(psiconv_paint_data_section sec)
34	frodo	32	{
35			Image *image;
36	frodo	49	float pixel, p, red, green, *blue;
37			int x,y;
38			ExceptionInfo *exc;
39
40			GetExceptionInfo(exc);
41			red = sec->red;
42			green = sec->green;
43			blue = sec->blue;
44			p = pixel = malloc(sec->xsize * sec->ysize * 3 * sizeof(float));
45			for (y = 0; y < sec->ysize; y++) {
46			for (x = 0; x < sec->xsize; x++) {
47			p++ = red++;
48			p++ = green++;
49			p++ = blue++;
50			}
51			}
52			image = ConstituteImage(sec->xsize,sec->ysize,"RGB",FloatPixel,pixel,exc);
53			free(pixel);
54			DestroyExceptionInfo(exc);
55
56	frodo	39	return image;
57	frodo	32	}
58
59	frodo	48	#endif
60	frodo	39
61	frodo	44	static int psiconv_gen_image_clipart(FILE *of, psiconv_clipart_f f,
62			const char *dest)
63			{
64			#if IMAGEMAGICK
65			psiconv_clipart_section section;
66			MagickInfo *mi = GetMagickInfo(dest);
67			ImageInfo image_info;
68			Image *image = NULL;
69			Image *last_image = NULL;
70			Image *this_image;
71			int i;
72
73			if ((psiconv_list_length(f->sections) < 1) \|\|
74			((psiconv_list_length(f->sections)) > 1 && ! (mi->adjoin)))
75			#endif
76			return -1;
77			#if IMAGEMAGICK
78			for (i = 0; i < psiconv_list_length(f->sections); i++) {
79			section = psiconv_list_get(f->sections,i);
80			this_image = get_paint_data_section(section->picture);
81			if (! image) {
82			image = this_image;
83			last_image = image;
84			} else {
85			last_image->next=this_image;
86			this_image->previous=last_image;
87			this_image->scene=i;
88			last_image=this_image;
89			}
90			}
91
92			GetImageInfo(&image_info);
93			image_info.file = of;
94			strcpy(image->magick, dest);
95			image_info.adjoin=1;
96			WriteImage(&image_info,image);
97			return 0;
98			#endif
99			}
100
101	frodo	38	static int psiconv_gen_image_mbm(FILE of, psiconv_mbm_f f, const char dest)
102	frodo	32	{
103	frodo	39	#if IMAGEMAGICK
104	frodo	32	psiconv_paint_data_section section;
105	frodo	38	MagickInfo *mi = GetMagickInfo(dest);
106	frodo	39	ImageInfo image_info;
107			Image *image = NULL;
108			Image *last_image = NULL;
109			Image *this_image;
110			int i;
111
112			if ((psiconv_list_length(f->sections) < 1) \|\|
113			((psiconv_list_length(f->sections)) > 1 && ! (mi->adjoin)))
114	frodo	38	#endif
115	frodo	39	return -1;
116			#if IMAGEMAGICK
117			for (i = 0; i < psiconv_list_length(f->sections); i++) {
118	frodo	40	section = psiconv_list_get(f->sections,i);
119	frodo	39	this_image = get_paint_data_section(section);
120			if (! image) {
121	frodo	40	image = this_image;
122	frodo	39	last_image = image;
123			} else {
124			last_image->next=this_image;
125			this_image->previous=last_image;
126	frodo	40	this_image->scene=i;
127			last_image=this_image;
128	frodo	39	}
129			}
130	frodo	40
131	frodo	39	GetImageInfo(&image_info);
132			image_info.file = of;
133			strcpy(image->magick, dest);
134	frodo	40	image_info.adjoin=1;
135	frodo	39	WriteImage(&image_info,image);
136			return 0;
137	frodo	38	#endif
138	frodo	32	}
139
140	frodo	39	static void psiconv_gen_image_sketch(FILE *of, psiconv_sketch_f f,
141			const char *dest)
142	frodo	32	{
143	frodo	39	#if IMAGEMAGICK
144			ImageInfo image_info;
145			Image *image;
146
147			image = get_paint_data_section(f->sketch_sec->picture);
148			GetImageInfo(&image_info);
149			image_info.file = of;
150			strcpy(image->magick, dest);
151			WriteImage(&image_info,image);
152			#endif
153	frodo	32	}
154
155	frodo	34	static int psiconv_gen_image(FILE * of, const psiconv_file file,
156			const char *dest)
157	frodo	32	{
158	frodo	38	if (file->type == psiconv_mbm_file)
159			return psiconv_gen_image_mbm(of,(psiconv_mbm_f) file->file,dest);
160	frodo	44	if (file->type == psiconv_clipart_file)
161			return psiconv_gen_image_clipart(of,(psiconv_clipart_f) file->file,dest);
162	frodo	38	else if (file->type == psiconv_sketch_file) {
163	frodo	34	psiconv_gen_image_sketch(of,(psiconv_sketch_f) file->file,dest);
164			return 0;
165			} else
166			return -1;
167	frodo	32	}
168
169	frodo	34	void init_image(void)
170			{
171			struct psiconv_fileformat ff;
172			#if IMAGEMAGICK
173			MagickInfo *mi;
174			ff.output = psiconv_gen_image;
175			for (mi = GetMagickInfo(NULL); mi ; mi = mi->next) {
176			if (mi->encoder) {
177			ff.name = strdup(mi->tag);
178			ff.description = strdup(mi->description);
179			psiconv_list_add(fileformat_list,&ff);
180			}
181			}
182			#endif
183			}
184
frodo@frodo.looijaard.name	ViewVC Help
Powered by ViewVC 1.1.26