[occt.git] / src / OpenGl / OpenGl_ImageBox.cxx

/*
* Fonction
* ~~~~~~~~
*   Gestion des images sous OpenGL
*
*
* Attention:
* ~~~~~~~~~~~
*  Ce package a ete teste sur SGI, OSF, SUN, HP et WNT.
*
*
* Historique des modifications
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*   22-05-97: PCT ; creation
*   10-07-98: FGU ; Ajout : ReadScaledImage 
*                   Mise a jour des dimensions de l image
*    02.15.100 JR : Implicit convertion
*/
/*----------------------------------------------------------------------*/

/*----------------------------------------------------------------------*/
/*
* Includes
*/

#include <stdio.h>
#include <stdlib.h> 
#include <string.h>

#include <OpenGl_ImageBox.hxx>

/*----------------------------------------------------------------------*/
/*
* Types definis
*/

typedef struct _ImageRec {
  unsigned short imagic;
  unsigned short type;
  unsigned short dim;
  unsigned short xsize, ysize, zsize;
  unsigned int min, max;
  unsigned int wasteBytes;
  char name[80];
  unsigned long colorMap;
  FILE *file;
  unsigned char *tmp, *tmpR, *tmpG, *tmpB;
  unsigned long rleEnd;
  unsigned int *rowStart;
  int *rowSize;
} ImageRec;

/*----------------------------------------------------------------------*/
/*
* Fonctions privees
*/

static void
ConvertShort(unsigned short *array, long length) {
  unsigned long b1, b2;
  unsigned char *ptr;

  ptr = (unsigned char *)array;
  while (length--) {
    b1 = *ptr++;
    b2 = *ptr++;
    *array++ = (unsigned short )((b1 << 8) | (b2));
  }
}
/*----------------------------------------------------------------------*/

static void
ConvertLong(unsigned *array, long length) {
  unsigned long b1, b2, b3, b4;
  unsigned char *ptr;

  ptr = (unsigned char *)array;
  while (length--) {
    b1 = *ptr++;
    b2 = *ptr++;
    b3 = *ptr++;
    b4 = *ptr++;
    *array++ = (b1 << 24) | (b2 << 16) | (b3 << 8) | (b4);
  }
}
/*----------------------------------------------------------------------*/

static ImageRec *ImageOpen(char *fileName)
{
  union {
    int testWord;
    char testByte[4];
  } endianTest;
  ImageRec *image;
  int swapFlag;
  int x;

  endianTest.testWord = 1;
  if (endianTest.testByte[0] == 1) {
    swapFlag = 1;
  } else {
    swapFlag = 0;
  }

  image = (ImageRec *)malloc(sizeof(ImageRec));
  if (image == NULL) {
    fprintf(stderr, "Out of memory!\n");
    exit(1);
  }
  if ((image->file = fopen(fileName, "rb")) == NULL) {
    perror(fileName);
    exit(1);
  }

  fread(image, 1, 12, image->file);

  if (swapFlag) {
    ConvertShort(&image->imagic, 6);
  }

  image->tmp = (unsigned char *)malloc(image->xsize*256);
  image->tmpR = (unsigned char *)malloc(image->xsize*256);
  image->tmpG = (unsigned char *)malloc(image->xsize*256);
  image->tmpB = (unsigned char *)malloc(image->xsize*256);
  if (image->tmp == NULL || image->tmpR == NULL || image->tmpG == NULL ||
    image->tmpB == NULL) {
      fprintf(stderr, "Out of memory!\n");
      exit(1);
    }

    if ((image->type & 0xFF00) == 0x0100) {
      x = image->ysize * image->zsize * sizeof(unsigned);
      image->rowStart = (unsigned *)malloc(x);
      image->rowSize = (int *)malloc(x);
      if (image->rowStart == NULL || image->rowSize == NULL) {
        fprintf(stderr, "Out of memory!\n");
        exit(1);
      }
      image->rleEnd = 512 + (2 * x);
      fseek(image->file, 512, SEEK_SET);
      fread(image->rowStart, 1, x, image->file);
      fread(image->rowSize, 1, x, image->file);
      if (swapFlag) {
        ConvertLong(image->rowStart, x/sizeof(unsigned));
        ConvertLong((unsigned *)image->rowSize, x/sizeof(int));
      }
    }
    return image;
}
/*----------------------------------------------------------------------*/

static void
ImageClose(ImageRec *image) {
  fclose(image->file);
  free(image->tmp);
  free(image->tmpR);
  free(image->tmpG);
  free(image->tmpB);
  free(image);
}
/*----------------------------------------------------------------------*/

static void
ImageGetRow(ImageRec *image, unsigned char *buf, int y, int z) {
  unsigned char *iPtr, *oPtr, pixel;
  int count;

  if ((image->type & 0xFF00) == 0x0100) {
    fseek(image->file, image->rowStart[y+z*image->ysize], SEEK_SET);
    fread(image->tmp, 1, (unsigned int)image->rowSize[y+z*image->ysize],
      image->file);

    iPtr = image->tmp;
    oPtr = buf;
    while (1) {
      pixel = *iPtr++;
      count = (int)(pixel & 0x7F);
      if (!count) {
        return;
      }
      if (pixel & 0x80) {
        while (count--) {
          *oPtr++ = *iPtr++;
        }
      } else {
        pixel = *iPtr++;
        while (count--) {
          *oPtr++ = pixel;
        }
      }
    }
  } else {
    fseek(image->file, 512+(y*image->xsize)+(z*image->xsize*image->ysize),
      SEEK_SET);
    fread(buf, 1, image->xsize, image->file);
  }
}

/*----------------------------------------------------------------------*/
/*
* Fonctions publiques 
*/

/*----------------------------------------------------------------------*/
void ReadScaledImage(char *file, int xsize, int ysize, char *buf, unsigned short *zsize)
{    
  ImageRec *image = ImageOpen(file);
  unsigned char *rbuf, *gbuf=NULL, *bbuf=NULL;    
  int row, rrow, i, ri;
  char *p = buf;

  *zsize = image->zsize;

  /* Allocation memoire */
  rbuf=(unsigned char *)malloc(image->xsize * sizeof(unsigned char));

  if (image->zsize > 2) {
    gbuf = (unsigned char *) malloc (image->xsize * sizeof(unsigned char));
    bbuf = (unsigned char *) malloc (image->xsize * sizeof(unsigned char));
  }

  /* Lecture image rang apres rang */    
  for (row = 0; row < ysize; row++) {
    /* rang a lire */
    rrow = (row*image->ysize)/ysize;

    if (*zsize > 2) {
      ImageGetRow(image, rbuf, rrow, 0);
      ImageGetRow(image, gbuf, rrow, 1);
      ImageGetRow(image, bbuf, rrow, 2);
    }
    else
      ImageGetRow(image, rbuf, rrow, 0);

    /* stockage au format RGB */
    for (i=0; i < xsize; i++) {
      ri = (i*image->xsize)/xsize;
      if (*zsize > 2) {
        *p++ = rbuf[ri];
        *p++ = gbuf[ri];
        *p++ = bbuf[ri];
      }
      else {
        *p++ = rbuf[ri];
        *p++ = rbuf[ri];
        *p++ = rbuf[ri];
      }
    }
  }

  /* delete image buffers */
  free(rbuf);
  if (*zsize > 2) {
    free(gbuf);
    free(bbuf);
  }

  ImageClose(image);    
}

/*----------------------------------------------------------------------*/
void ReadSizeImage(char *file, int *xsize, int *ysize)
{
  /* Lecture image */
  ImageRec *image = ImageOpen(file);

  /* Affectation taille */
  *xsize = image->xsize;
  *ysize = image->ysize;
}

/*----------------------------------------------------------------------*/
void bwtorgba(unsigned char *b,unsigned char *l,int n) {
  while(n--) {
    l[0] = *b;
    l[1] = *b;
    l[2] = *b;
    l[3] = 0xff;
    l += 4; b++;
  }
}

/*----------------------------------------------------------------------*/

void rgbtorgba(unsigned char *r,unsigned char *g,unsigned char *b,unsigned char *l,int n) {
  while(n--) {
    l[0] = r[0];
    l[1] = g[0];
    l[2] = b[0];
    l[3] = 0xff;
    l += 4; r++; g++; b++;
  }
}

/*----------------------------------------------------------------------*/

void rgbatorgba(unsigned char *r,unsigned char *g,unsigned char *b,unsigned char *a,unsigned char *l,int n) {
  while(n--) {
    l[0] = r[0];
    l[1] = g[0];
    l[2] = b[0];
    l[3] = a[0];
    l += 4; r++; g++; b++; a++;
  }
}

/*----------------------------------------------------------------------*/

unsigned *
read_texture(char *name, int *width, int *height, int *components) {
  unsigned *base, *lptr;
  unsigned char *rbuf, *gbuf, *bbuf, *abuf;
  ImageRec *image;
  int y;

  image = ImageOpen(name);

  if(!image)
    return NULL;
  (*width)=image->xsize;
  (*height)=image->ysize;
  (*components)=image->zsize;
  base = (unsigned *)malloc(image->xsize*image->ysize*sizeof(unsigned));
  rbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
  gbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
  bbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
  abuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
  if(!base || !rbuf || !gbuf || !bbuf)
    return NULL;
  lptr = base;
  for(y=0; y<image->ysize; y++) {
    if(image->zsize>=4) {
      ImageGetRow(image,rbuf,y,0);
      ImageGetRow(image,gbuf,y,1);
      ImageGetRow(image,bbuf,y,2);
      ImageGetRow(image,abuf,y,3);
      rgbatorgba(rbuf,gbuf,bbuf,abuf,(unsigned char *)lptr,image->xsize);
      lptr += image->xsize;
    } else if(image->zsize==3) {
      ImageGetRow(image,rbuf,y,0);
      ImageGetRow(image,gbuf,y,1);
      ImageGetRow(image,bbuf,y,2);
      rgbtorgba(rbuf,gbuf,bbuf,(unsigned char *)lptr,image->xsize);
      lptr += image->xsize;
    } else {
      ImageGetRow(image,rbuf,y,0);
      bwtorgba(rbuf,(unsigned char *)lptr,image->xsize);
      lptr += image->xsize;
    }
  }
  ImageClose(image);
  free(rbuf);
  free(gbuf);
  free(bbuf);
  free(abuf);

  return (unsigned *) base;
}

/*----------------------------------------------------------------------*/
Commit	Line	Data
7fd59977	1	/*
	2	* Fonction
	3	* ~~~~~~~~
	4	* Gestion des images sous OpenGL
	5	*
	6	*
	7	* Attention:
	8	* ~~~~~~~~~~~
	9	* Ce package a ete teste sur SGI, OSF, SUN, HP et WNT.
	10	*
	11	*
	12	* Historique des modifications
	13	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	14	* 22-05-97: PCT ; creation
	15	* 10-07-98: FGU ; Ajout : ReadScaledImage
	16	* Mise a jour des dimensions de l image
	17	* 02.15.100 JR : Implicit convertion
	18	*/
	19	/----------------------------------------------------------------------/
	20
	21	/----------------------------------------------------------------------/
	22	/*
	23	* Includes
	24	*/
	25
	26	#include <stdio.h>
	27	#include <stdlib.h>
	28	#include <string.h>
	29
	30	#include <OpenGl_ImageBox.hxx>
	31
	32	/----------------------------------------------------------------------/
	33	/*
	34	* Types definis
	35	*/
	36
	37	typedef struct _ImageRec {
	38	unsigned short imagic;
	39	unsigned short type;
	40	unsigned short dim;
	41	unsigned short xsize, ysize, zsize;
	42	unsigned int min, max;
	43	unsigned int wasteBytes;
	44	char name[80];
	45	unsigned long colorMap;
	46	FILE *file;
	47	unsigned char tmp, tmpR, tmpG, tmpB;
	48	unsigned long rleEnd;
	49	unsigned int *rowStart;
	50	int *rowSize;
	51	} ImageRec;
	52
	53	/----------------------------------------------------------------------/
	54	/*
	55	* Fonctions privees
	56	*/
	57
	58	static void
	59	ConvertShort(unsigned short *array, long length) {
	60	unsigned long b1, b2;
	61	unsigned char *ptr;
	62
	63	ptr = (unsigned char *)array;
	64	while (length--) {
65	b1 = *ptr++;
66	b2 = *ptr++;
67	*array++ = (unsigned short )((b1 << 8) \| (b2));
68	}
69	}
70	/----------------------------------------------------------------------/
71
72	static void
73	ConvertLong(unsigned *array, long length) {
74	unsigned long b1, b2, b3, b4;
75	unsigned char *ptr;
76
77	ptr = (unsigned char *)array;
78	while (length--) {
79	b1 = *ptr++;
80	b2 = *ptr++;
81	b3 = *ptr++;
82	b4 = *ptr++;
83	*array++ = (b1 << 24) \| (b2 << 16) \| (b3 << 8) \| (b4);
84	}
85	}
86	/----------------------------------------------------------------------/
87
88	static ImageRec ImageOpen(char fileName)
89	{
90	union {
91	int testWord;
92	char testByte[4];
93	} endianTest;
94	ImageRec *image;
95	int swapFlag;
96	int x;
97
98	endianTest.testWord = 1;
99	if (endianTest.testByte[0] == 1) {
100	swapFlag = 1;
101	} else {
102	swapFlag = 0;
103	}
104
105	image = (ImageRec *)malloc(sizeof(ImageRec));
106	if (image == NULL) {
107	fprintf(stderr, "Out of memory!\n");
108	exit(1);
109	}
110	if ((image->file = fopen(fileName, "rb")) == NULL) {
111	perror(fileName);
112	exit(1);
113	}
114
115	fread(image, 1, 12, image->file);
116
117	if (swapFlag) {
118	ConvertShort(&image->imagic, 6);
119	}
120
121	image->tmp = (unsigned char )malloc(image->xsize256);
122	image->tmpR = (unsigned char )malloc(image->xsize256);
123	image->tmpG = (unsigned char )malloc(image->xsize256);
124	image->tmpB = (unsigned char )malloc(image->xsize256);
125	if (image->tmp == NULL \|\| image->tmpR == NULL \|\| image->tmpG == NULL \|\|
126	image->tmpB == NULL) {
127	fprintf(stderr, "Out of memory!\n");
128	exit(1);
129	}
130
131	if ((image->type & 0xFF00) == 0x0100) {
132	x = image->ysize * image->zsize * sizeof(unsigned);
133	image->rowStart = (unsigned *)malloc(x);
134	image->rowSize = (int *)malloc(x);
135	if (image->rowStart == NULL \|\| image->rowSize == NULL) {
136	fprintf(stderr, "Out of memory!\n");
137	exit(1);
138	}
139	image->rleEnd = 512 + (2 * x);
140	fseek(image->file, 512, SEEK_SET);
141	fread(image->rowStart, 1, x, image->file);
142	fread(image->rowSize, 1, x, image->file);
143	if (swapFlag) {
144	ConvertLong(image->rowStart, x/sizeof(unsigned));
145	ConvertLong((unsigned *)image->rowSize, x/sizeof(int));
146	}
147	}
148	return image;
149	}
150	/----------------------------------------------------------------------/
151
152	static void
153	ImageClose(ImageRec *image) {
154	fclose(image->file);
155	free(image->tmp);
156	free(image->tmpR);
157	free(image->tmpG);
158	free(image->tmpB);
159	free(image);
160	}
161	/----------------------------------------------------------------------/
162
163	static void
164	ImageGetRow(ImageRec image, unsigned char buf, int y, int z) {
165	unsigned char iPtr, oPtr, pixel;
166	int count;
167
168	if ((image->type & 0xFF00) == 0x0100) {
169	fseek(image->file, image->rowStart[y+z*image->ysize], SEEK_SET);
170	fread(image->tmp, 1, (unsigned int)image->rowSize[y+z*image->ysize],
171	image->file);
172
173	iPtr = image->tmp;
174	oPtr = buf;
175	while (1) {
176	pixel = *iPtr++;
177	count = (int)(pixel & 0x7F);
178	if (!count) {
179	return;
180	}
181	if (pixel & 0x80) {
182	while (count--) {
183	oPtr++ = iPtr++;
184	}
185	} else {
186	pixel = *iPtr++;
187	while (count--) {
188	*oPtr++ = pixel;
189	}
190	}
191	}
192	} else {
193	fseek(image->file, 512+(yimage->xsize)+(zimage->xsize*image->ysize),
194	SEEK_SET);
195	fread(buf, 1, image->xsize, image->file);
196	}
197	}
198
199	/----------------------------------------------------------------------/
200	/*
201	* Fonctions publiques
202	*/
203
204	/----------------------------------------------------------------------/
205	void ReadScaledImage(char file, int xsize, int ysize, char buf, unsigned short *zsize)
206	{
207	ImageRec *image = ImageOpen(file);
208	unsigned char rbuf, gbuf=NULL, *bbuf=NULL;
209	int row, rrow, i, ri;
210	char *p = buf;
211
212	*zsize = image->zsize;
213
214	/* Allocation memoire */
215	rbuf=(unsigned char )malloc(image->xsize sizeof(unsigned char));
216
217	if (image->zsize > 2) {
218	gbuf = (unsigned char ) malloc (image->xsize sizeof(unsigned char));
219	bbuf = (unsigned char ) malloc (image->xsize sizeof(unsigned char));
220	}
221
222	/* Lecture image rang apres rang */
223	for (row = 0; row < ysize; row++) {
224	/* rang a lire */
225	rrow = (row*image->ysize)/ysize;
226
227	if (*zsize > 2) {
228	ImageGetRow(image, rbuf, rrow, 0);
229	ImageGetRow(image, gbuf, rrow, 1);
230	ImageGetRow(image, bbuf, rrow, 2);
231	}
232	else
233	ImageGetRow(image, rbuf, rrow, 0);
234
235	/* stockage au format RGB */
236	for (i=0; i < xsize; i++) {
237	ri = (i*image->xsize)/xsize;
238	if (*zsize > 2) {
239	*p++ = rbuf[ri];
240	*p++ = gbuf[ri];
241	*p++ = bbuf[ri];
242	}
243	else {
244	*p++ = rbuf[ri];
245	*p++ = rbuf[ri];
246	*p++ = rbuf[ri];
247	}
248	}
249	}
250
251	/* delete image buffers */
252	free(rbuf);
253	if (*zsize > 2) {
254	free(gbuf);
255	free(bbuf);
256	}
257
258	ImageClose(image);
259	}
260
261	/----------------------------------------------------------------------/
262	void ReadSizeImage(char file, int xsize, int *ysize)
263	{
264	/* Lecture image */
265	ImageRec *image = ImageOpen(file);
266
267	/* Affectation taille */
268	*xsize = image->xsize;
269	*ysize = image->ysize;
270	}
271
272	/----------------------------------------------------------------------/
273	void bwtorgba(unsigned char b,unsigned char l,int n) {
274	while(n--) {
275	l[0] = *b;
276	l[1] = *b;
277	l[2] = *b;
278	l[3] = 0xff;
279	l += 4; b++;
280	}
281	}
282
283	/----------------------------------------------------------------------/
284
285	void rgbtorgba(unsigned char r,unsigned char g,unsigned char b,unsigned char l,int n) {
286	while(n--) {
287	l[0] = r[0];
288	l[1] = g[0];
289	l[2] = b[0];
290	l[3] = 0xff;
291	l += 4; r++; g++; b++;
292	}
293	}
294
295	/----------------------------------------------------------------------/
296
297	void rgbatorgba(unsigned char r,unsigned char g,unsigned char b,unsigned char a,unsigned char *l,int n) {
298	while(n--) {
299	l[0] = r[0];
300	l[1] = g[0];
301	l[2] = b[0];
302	l[3] = a[0];
303	l += 4; r++; g++; b++; a++;
304	}
305	}
306
307	/----------------------------------------------------------------------/
308
309	unsigned *
310	read_texture(char name, int width, int height, int components) {
311	unsigned base, lptr;
312	unsigned char rbuf, gbuf, bbuf, abuf;
313	ImageRec *image;
314	int y;
315
316	image = ImageOpen(name);
317
318	if(!image)
319	return NULL;
320	(*width)=image->xsize;
321	(*height)=image->ysize;
322	(*components)=image->zsize;
323	base = (unsigned )malloc(image->xsizeimage->ysize*sizeof(unsigned));
324	rbuf = (unsigned char )malloc(image->xsizesizeof(unsigned char));
325	gbuf = (unsigned char )malloc(image->xsizesizeof(unsigned char));
326	bbuf = (unsigned char )malloc(image->xsizesizeof(unsigned char));
327	abuf = (unsigned char )malloc(image->xsizesizeof(unsigned char));
328	if(!base \|\| !rbuf \|\| !gbuf \|\| !bbuf)
329	return NULL;
330	lptr = base;
331	for(y=0; y<image->ysize; y++) {
332	if(image->zsize>=4) {
333	ImageGetRow(image,rbuf,y,0);
334	ImageGetRow(image,gbuf,y,1);
335	ImageGetRow(image,bbuf,y,2);
336	ImageGetRow(image,abuf,y,3);
337	rgbatorgba(rbuf,gbuf,bbuf,abuf,(unsigned char *)lptr,image->xsize);
338	lptr += image->xsize;
339	} else if(image->zsize==3) {
340	ImageGetRow(image,rbuf,y,0);
341	ImageGetRow(image,gbuf,y,1);
342	ImageGetRow(image,bbuf,y,2);
343	rgbtorgba(rbuf,gbuf,bbuf,(unsigned char *)lptr,image->xsize);
344	lptr += image->xsize;
345	} else {
346	ImageGetRow(image,rbuf,y,0);
347	bwtorgba(rbuf,(unsigned char *)lptr,image->xsize);
348	lptr += image->xsize;
349	}
350	}
351	ImageClose(image);
352	free(rbuf);
353	free(gbuf);
354	free(bbuf);
355	free(abuf);
356
357	return (unsigned *) base;
358	}
359
360	/----------------------------------------------------------------------/