Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

ximatran.cpp@ 404

Last change on this file since 404 was 95, checked in by Rick van der Zwet, 15 years ago
Bad boy, improper move of directory
File size: 83.5 KB

Line
1	// xImaTran.cpp : Transformation functions
2	/* 07/08/2001 v1.00 - Davide Pizzolato - www.xdp.it
3	* CxImage version 6.0.0 02/Feb/2008
4	*/
5
6	#include "ximage.h"
7	#include "ximath.h"
8
9	#if CXIMAGE_SUPPORT_BASICTRANSFORMATIONS
10	////////////////////////////////////////////////////////////////////////////////
11	bool CxImage::GrayScale()
12	{
13	if (!pDib) return false;
14	if (head.biBitCount<=8){
15	RGBQUAD* ppal=GetPalette();
16	int gray;
17	//converts the colors to gray, use the blue channel only
18	for(DWORD i=0;i<head.biClrUsed;i++){
19	gray=(int)RGB2GRAY(ppal[i].rgbRed,ppal[i].rgbGreen,ppal[i].rgbBlue);
20	ppal[i].rgbBlue = (BYTE)gray;
21	}
22	// preserve transparency
23	if (info.nBkgndIndex >= 0) info.nBkgndIndex = ppal[info.nBkgndIndex].rgbBlue;
24	//create a "real" 8 bit gray scale image
25	if (head.biBitCount==8){
26	BYTE *img=info.pImage;
27	for(DWORD i=0;i<head.biSizeImage;i++) img[i]=ppal[img[i]].rgbBlue;
28	SetGrayPalette();
29	}
30	//transform to 8 bit gray scale
31	if (head.biBitCount==4 \|\| head.biBitCount==1){
32	CxImage ima;
33	ima.CopyInfo(*this);
34	if (!ima.Create(head.biWidth,head.biHeight,8,info.dwType)) return false;
35	ima.SetGrayPalette();
36	#if CXIMAGE_SUPPORT_SELECTION
37	ima.SelectionCopy(*this);
38	#endif //CXIMAGE_SUPPORT_SELECTION
39	#if CXIMAGE_SUPPORT_ALPHA
40	ima.AlphaCopy(*this);
41	#endif //CXIMAGE_SUPPORT_ALPHA
42	for (long y=0;y<head.biHeight;y++){
43	BYTE *iDst = ima.GetBits(y);
44	BYTE *iSrc = GetBits(y);
45	for (long x=0;x<head.biWidth; x++){
46	//iDst[x]=ppal[BlindGetPixelIndex(x,y)].rgbBlue;
47	if (head.biBitCount==4){
48	BYTE pos = (BYTE)(4*(1-x%2));
49	iDst[x]= ppal[(BYTE)((iSrc[x >> 1]&((BYTE)0x0F<<pos)) >> pos)].rgbBlue;
50	} else {
51	BYTE pos = (BYTE)(7-x%8);
52	iDst[x]= ppal[(BYTE)((iSrc[x >> 3]&((BYTE)0x01<<pos)) >> pos)].rgbBlue;
53	}
54	}
55	}
56	Transfer(ima);
57	}
58	} else { //from RGB to 8 bit gray scale
59	BYTE *iSrc=info.pImage;
60	CxImage ima;
61	ima.CopyInfo(*this);
62	if (!ima.Create(head.biWidth,head.biHeight,8,info.dwType)) return false;
63	ima.SetGrayPalette();
64	#if CXIMAGE_SUPPORT_SELECTION
65	ima.SelectionCopy(*this);
66	#endif //CXIMAGE_SUPPORT_SELECTION
67	#if CXIMAGE_SUPPORT_ALPHA
68	ima.AlphaCopy(*this);
69	#endif //CXIMAGE_SUPPORT_ALPHA
70	BYTE *img=ima.GetBits();
71	long l8=ima.GetEffWidth();
72	long l=head.biWidth * 3;
73	for(long y=0; y < head.biHeight; y++) {
74	for(long x=0,x8=0; x < l; x+=3,x8++) {
75	img[x8+yl8]=(BYTE)RGB2GRAY((iSrc+x+2),(iSrc+x+1),(iSrc+x+0));
76	}
77	iSrc+=info.dwEffWidth;
78	}
79	Transfer(ima);
80	}
81	return true;
82	}
83	////////////////////////////////////////////////////////////////////////////////
84	/**
85	* \sa Mirror
86	* \author [qhbo]
87	*/
88	bool CxImage::Flip(bool bFlipSelection, bool bFlipAlpha)
89	{
90	if (!pDib) return false;
91
92	BYTE buff = (BYTE)malloc(info.dwEffWidth);
93	if (!buff) return false;
94
95	BYTE iSrc,iDst;
96	iSrc = GetBits(head.biHeight-1);
97	iDst = GetBits(0);
98	for (long i=0; i<(head.biHeight/2); ++i)
99	{
100	memcpy(buff, iSrc, info.dwEffWidth);
101	memcpy(iSrc, iDst, info.dwEffWidth);
102	memcpy(iDst, buff, info.dwEffWidth);
103	iSrc-=info.dwEffWidth;
104	iDst+=info.dwEffWidth;
105	}
106
107	free(buff);
108
109	if (bFlipSelection){
110	#if CXIMAGE_SUPPORT_SELECTION
111	SelectionFlip();
112	#endif //CXIMAGE_SUPPORT_SELECTION
113	}
114
115	if (bFlipAlpha){
116	#if CXIMAGE_SUPPORT_ALPHA
117	AlphaFlip();
118	#endif //CXIMAGE_SUPPORT_ALPHA
119	}
120
121	return true;
122	}
123	////////////////////////////////////////////////////////////////////////////////
124	/**
125	* \sa Flip
126	*/
127	bool CxImage::Mirror(bool bMirrorSelection, bool bMirrorAlpha)
128	{
129	if (!pDib) return false;
130
131	CxImage* imatmp = new CxImage(*this,false,true,true);
132	if (!imatmp) return false;
133	if (!imatmp->IsValid()){
134	delete imatmp;
135	return false;
136	}
137
138	BYTE iSrc,iDst;
139	long wdt=(head.biWidth-1) * (head.biBitCount==24 ? 3:1);
140	iSrc=info.pImage + wdt;
141	iDst=imatmp->info.pImage;
142	long x,y;
143	switch (head.biBitCount){
144	case 24:
145	for(y=0; y < head.biHeight; y++){
146	for(x=0; x <= wdt; x+=3){
147	(iDst+x)=(iSrc-x);
148	(iDst+x+1)=(iSrc-x+1);
149	(iDst+x+2)=(iSrc-x+2);
150	}
151	iSrc+=info.dwEffWidth;
152	iDst+=info.dwEffWidth;
153	}
154	break;
155	case 8:
156	for(y=0; y < head.biHeight; y++){
157	for(x=0; x <= wdt; x++)
158	(iDst+x)=(iSrc-x);
159	iSrc+=info.dwEffWidth;
160	iDst+=info.dwEffWidth;
161	}
162	break;
163	default:
164	for(y=0; y < head.biHeight; y++){
165	for(x=0; x <= wdt; x++)
166	imatmp->SetPixelIndex(x,y,GetPixelIndex(wdt-x,y));
167	}
168	}
169
170	if (bMirrorSelection){
171	#if CXIMAGE_SUPPORT_SELECTION
172	imatmp->SelectionMirror();
173	#endif //CXIMAGE_SUPPORT_SELECTION
174	}
175
176	if (bMirrorAlpha){
177	#if CXIMAGE_SUPPORT_ALPHA
178	imatmp->AlphaMirror();
179	#endif //CXIMAGE_SUPPORT_ALPHA
180	}
181
182	Transfer(*imatmp);
183	delete imatmp;
184	return true;
185	}
186
187	////////////////////////////////////////////////////////////////////////////////
188	#define RBLOCK 64
189
190	////////////////////////////////////////////////////////////////////////////////
191	bool CxImage::RotateLeft(CxImage* iDst)
192	{
193	if (!pDib) return false;
194
195	long newWidth = GetHeight();
196	long newHeight = GetWidth();
197
198	CxImage imgDest;
199	imgDest.CopyInfo(*this);
200	imgDest.Create(newWidth,newHeight,GetBpp(),GetType());
201	imgDest.SetPalette(GetPalette());
202
203	#if CXIMAGE_SUPPORT_ALPHA
204	if (AlphaIsValid()) imgDest.AlphaCreate();
205	#endif
206
207	#if CXIMAGE_SUPPORT_SELECTION
208	if (SelectionIsValid()) imgDest.SelectionCreate();
209	#endif
210
211	long x,x2,y,dlineup;
212
213	// Speedy rotate for BW images <Robert Abram>
214	if (head.biBitCount == 1) {
215
216	BYTE sbits, dbits, dbitsmax, bitpos, nrow,*srcdisp;
217	ldiv_t div_r;
218
219	BYTE bsrc = GetBits(), bdest = imgDest.GetBits();
220	dbitsmax = bdest + imgDest.head.biSizeImage - 1;
221	dlineup = 8 * imgDest.info.dwEffWidth - imgDest.head.biWidth;
222
223	imgDest.Clear(0);
224	for (y = 0; y < head.biHeight; y++) {
225	// Figure out the Column we are going to be copying to
226	div_r = ldiv(y + dlineup, (long)8);
227	// set bit pos of src column byte
228	bitpos = (BYTE)(1 << div_r.rem);
229	srcdisp = bsrc + y * info.dwEffWidth;
230	for (x = 0; x < (long)info.dwEffWidth; x++) {
231	// Get Source Bits
232	sbits = srcdisp + x;
233	// Get destination column
234	nrow = bdest + (x * 8) * imgDest.info.dwEffWidth + imgDest.info.dwEffWidth - 1 - div_r.quot;
235	for (long z = 0; z < 8; z++) {
236	// Get Destination Byte
237	dbits = nrow + z * imgDest.info.dwEffWidth;
238	if ((dbits < bdest) \|\| (dbits > dbitsmax)) break;
239	if (sbits & (128 >> z)) dbits \|= bitpos;
240	}
241	}
242	}//for y
243
244	#if CXIMAGE_SUPPORT_ALPHA
245	if (AlphaIsValid()) {
246	for (x = 0; x < newWidth; x++){
247	x2=newWidth-x-1;
248	for (y = 0; y < newHeight; y++){
249	imgDest.AlphaSet(x,y,BlindAlphaGet(y, x2));
250	}//for y
251	}//for x
252	}
253	#endif //CXIMAGE_SUPPORT_ALPHA
254
255	#if CXIMAGE_SUPPORT_SELECTION
256	if (SelectionIsValid()) {
257	imgDest.info.rSelectionBox.left = newWidth-info.rSelectionBox.top;
258	imgDest.info.rSelectionBox.right = newWidth-info.rSelectionBox.bottom;
259	imgDest.info.rSelectionBox.bottom = info.rSelectionBox.left;
260	imgDest.info.rSelectionBox.top = info.rSelectionBox.right;
261	for (x = 0; x < newWidth; x++){
262	x2=newWidth-x-1;
263	for (y = 0; y < newHeight; y++){
264	imgDest.SelectionSet(x,y,BlindSelectionGet(y, x2));
265	}//for y
266	}//for x
267	}
268	#endif //CXIMAGE_SUPPORT_SELECTION
269
270	} else {
271	//anything other than BW:
272	//bd, 10. 2004: This optimized version of rotation rotates image by smaller blocks. It is quite
273	//a bit faster than obvious algorithm, because it produces much less CPU cache misses.
274	//This optimization can be tuned by changing block size (RBLOCK). 96 is good value for current
275	//CPUs (tested on Athlon XP and Celeron D). Larger value (if CPU has enough cache) will increase
276	//speed somehow, but once you drop out of CPU's cache, things will slow down drastically.
277	//For older CPUs with less cache, lower value would yield better results.
278
279	BYTE srcPtr, dstPtr; //source and destionation for 24-bit version
280	int xs, ys; //x-segment and y-segment
281	for (xs = 0; xs < newWidth; xs+=RBLOCK) { //for all image blocks of RBLOCK*RBLOCK pixels
282	for (ys = 0; ys < newHeight; ys+=RBLOCK) {
283	if (head.biBitCount==24) {
284	//RGB24 optimized pixel access:
285	for (x = xs; x < min(newWidth, xs+RBLOCK); x++){ //do rotation
286	info.nProgress = (long)(100*x/newWidth);
287	x2=newWidth-x-1;
288	dstPtr = (BYTE*) imgDest.BlindGetPixelPointer(x,ys);
289	srcPtr = (BYTE*) BlindGetPixelPointer(ys, x2);
290	for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
291	//imgDest.SetPixelColor(x, y, GetPixelColor(y, x2));
292	(dstPtr) = (srcPtr);
293	(dstPtr+1) = (srcPtr+1);
294	(dstPtr+2) = (srcPtr+2);
295	srcPtr += 3;
296	dstPtr += imgDest.info.dwEffWidth;
297	}//for y
298	}//for x
299	} else {
300	//anything else than 24bpp (and 1bpp): palette
301	for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
302	info.nProgress = (long)(100*x/newWidth); //<Anatoly Ivasyuk>
303	x2=newWidth-x-1;
304	for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
305	imgDest.SetPixelIndex(x, y, BlindGetPixelIndex(y, x2));
306	}//for y
307	}//for x
308	}//if (version selection)
309	#if CXIMAGE_SUPPORT_ALPHA
310	if (AlphaIsValid()) {
311	for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
312	x2=newWidth-x-1;
313	for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
314	imgDest.AlphaSet(x,y,BlindAlphaGet(y, x2));
315	}//for y
316	}//for x
317	}//if (alpha channel)
318	#endif //CXIMAGE_SUPPORT_ALPHA
319
320	#if CXIMAGE_SUPPORT_SELECTION
321	if (SelectionIsValid()) {
322	imgDest.info.rSelectionBox.left = newWidth-info.rSelectionBox.top;
323	imgDest.info.rSelectionBox.right = newWidth-info.rSelectionBox.bottom;
324	imgDest.info.rSelectionBox.bottom = info.rSelectionBox.left;
325	imgDest.info.rSelectionBox.top = info.rSelectionBox.right;
326	for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
327	x2=newWidth-x-1;
328	for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
329	imgDest.SelectionSet(x,y,BlindSelectionGet(y, x2));
330	}//for y
331	}//for x
332	}//if (selection)
333	#endif //CXIMAGE_SUPPORT_SELECTION
334	}//for ys
335	}//for xs
336	}//if
337
338	//select the destination
339	if (iDst) iDst->Transfer(imgDest);
340	else Transfer(imgDest);
341	return true;
342	}
343
344	////////////////////////////////////////////////////////////////////////////////
345	bool CxImage::RotateRight(CxImage* iDst)
346	{
347	if (!pDib) return false;
348
349	long newWidth = GetHeight();
350	long newHeight = GetWidth();
351
352	CxImage imgDest;
353	imgDest.CopyInfo(*this);
354	imgDest.Create(newWidth,newHeight,GetBpp(),GetType());
355	imgDest.SetPalette(GetPalette());
356
357	#if CXIMAGE_SUPPORT_ALPHA
358	if (AlphaIsValid()) imgDest.AlphaCreate();
359	#endif
360
361	#if CXIMAGE_SUPPORT_SELECTION
362	if (SelectionIsValid()) imgDest.SelectionCreate();
363	#endif
364
365	long x,y,y2;
366	// Speedy rotate for BW images <Robert Abram>
367	if (head.biBitCount == 1) {
368
369	BYTE sbits, dbits, dbitsmax, bitpos, nrow,*srcdisp;
370	ldiv_t div_r;
371
372	BYTE bsrc = GetBits(), bdest = imgDest.GetBits();
373	dbitsmax = bdest + imgDest.head.biSizeImage - 1;
374
375	imgDest.Clear(0);
376	for (y = 0; y < head.biHeight; y++) {
377	// Figure out the Column we are going to be copying to
378	div_r = ldiv(y, (long)8);
379	// set bit pos of src column byte
380	bitpos = (BYTE)(128 >> div_r.rem);
381	srcdisp = bsrc + y * info.dwEffWidth;
382	for (x = 0; x < (long)info.dwEffWidth; x++) {
383	// Get Source Bits
384	sbits = srcdisp + x;
385	// Get destination column
386	nrow = bdest + (imgDest.head.biHeight-1-(x8)) imgDest.info.dwEffWidth + div_r.quot;
387	for (long z = 0; z < 8; z++) {
388	// Get Destination Byte
389	dbits = nrow - z * imgDest.info.dwEffWidth;
390	if ((dbits < bdest) \|\| (dbits > dbitsmax)) break;
391	if (sbits & (128 >> z)) dbits \|= bitpos;
392	}
393	}
394	}
395
396	#if CXIMAGE_SUPPORT_ALPHA
397	if (AlphaIsValid()){
398	for (y = 0; y < newHeight; y++){
399	y2=newHeight-y-1;
400	for (x = 0; x < newWidth; x++){
401	imgDest.AlphaSet(x,y,BlindAlphaGet(y2, x));
402	}
403	}
404	}
405	#endif //CXIMAGE_SUPPORT_ALPHA
406
407	#if CXIMAGE_SUPPORT_SELECTION
408	if (SelectionIsValid()){
409	imgDest.info.rSelectionBox.left = info.rSelectionBox.bottom;
410	imgDest.info.rSelectionBox.right = info.rSelectionBox.top;
411	imgDest.info.rSelectionBox.bottom = newHeight-info.rSelectionBox.right;
412	imgDest.info.rSelectionBox.top = newHeight-info.rSelectionBox.left;
413	for (y = 0; y < newHeight; y++){
414	y2=newHeight-y-1;
415	for (x = 0; x < newWidth; x++){
416	imgDest.SelectionSet(x,y,BlindSelectionGet(y2, x));
417	}
418	}
419	}
420	#endif //CXIMAGE_SUPPORT_SELECTION
421
422	} else {
423	//anything else but BW
424	BYTE srcPtr, dstPtr; //source and destionation for 24-bit version
425	int xs, ys; //x-segment and y-segment
426	for (xs = 0; xs < newWidth; xs+=RBLOCK) {
427	for (ys = 0; ys < newHeight; ys+=RBLOCK) {
428	if (head.biBitCount==24) {
429	//RGB24 optimized pixel access:
430	for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
431	info.nProgress = (long)(100*y/newHeight); //<Anatoly Ivasyuk>
432	y2=newHeight-y-1;
433	dstPtr = (BYTE*) imgDest.BlindGetPixelPointer(xs,y);
434	srcPtr = (BYTE*) BlindGetPixelPointer(y2, xs);
435	for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
436	//imgDest.SetPixelColor(x, y, GetPixelColor(y2, x));
437	(dstPtr) = (srcPtr);
438	(dstPtr+1) = (srcPtr+1);
439	(dstPtr+2) = (srcPtr+2);
440	dstPtr += 3;
441	srcPtr += info.dwEffWidth;
442	}//for x
443	}//for y
444	} else {
445	//anything else than BW & RGB24: palette
446	for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
447	info.nProgress = (long)(100*y/newHeight); //<Anatoly Ivasyuk>
448	y2=newHeight-y-1;
449	for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
450	imgDest.SetPixelIndex(x, y, BlindGetPixelIndex(y2, x));
451	}//for x
452	}//for y
453	}//if
454	#if CXIMAGE_SUPPORT_ALPHA
455	if (AlphaIsValid()){
456	for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
457	y2=newHeight-y-1;
458	for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
459	imgDest.AlphaSet(x,y,BlindAlphaGet(y2, x));
460	}//for x
461	}//for y
462	}//if (has alpha)
463	#endif //CXIMAGE_SUPPORT_ALPHA
464
465	#if CXIMAGE_SUPPORT_SELECTION
466	if (SelectionIsValid()){
467	imgDest.info.rSelectionBox.left = info.rSelectionBox.bottom;
468	imgDest.info.rSelectionBox.right = info.rSelectionBox.top;
469	imgDest.info.rSelectionBox.bottom = newHeight-info.rSelectionBox.right;
470	imgDest.info.rSelectionBox.top = newHeight-info.rSelectionBox.left;
471	for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
472	y2=newHeight-y-1;
473	for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
474	imgDest.SelectionSet(x,y,BlindSelectionGet(y2, x));
475	}//for x
476	}//for y
477	}//if (has alpha)
478	#endif //CXIMAGE_SUPPORT_SELECTION
479	}//for ys
480	}//for xs
481	}//if
482
483	//select the destination
484	if (iDst) iDst->Transfer(imgDest);
485	else Transfer(imgDest);
486	return true;
487	}
488
489	////////////////////////////////////////////////////////////////////////////////
490	bool CxImage::Negative()
491	{
492	if (!pDib) return false;
493
494	if (head.biBitCount<=8){
495	if (IsGrayScale()){ //GRAYSCALE, selection
496	if (pSelection){
497	for(long y=info.rSelectionBox.bottom; y<info.rSelectionBox.top; y++){
498	for(long x=info.rSelectionBox.left; x<info.rSelectionBox.right; x++){
499	#if CXIMAGE_SUPPORT_SELECTION
500	if (BlindSelectionIsInside(x,y))
501	#endif //CXIMAGE_SUPPORT_SELECTION
502	{
503	BlindSetPixelIndex(x,y,(BYTE)(255-BlindGetPixelIndex(x,y)));
504	}
505	}
506	}
507	} else {
508	BYTE *iSrc=info.pImage;
509	for(unsigned long i=0; i < head.biSizeImage; i++){
510	iSrc=(BYTE)~((iSrc));
511	iSrc++;
512	}
513	}
514	} else { //PALETTE, full image
515	RGBQUAD* ppal=GetPalette();
516	for(DWORD i=0;i<head.biClrUsed;i++){
517	ppal[i].rgbBlue =(BYTE)(255-ppal[i].rgbBlue);
518	ppal[i].rgbGreen =(BYTE)(255-ppal[i].rgbGreen);
519	ppal[i].rgbRed =(BYTE)(255-ppal[i].rgbRed);
520	}
521	}
522	} else {
523	if (pSelection==NULL){ //RGB, full image
524	BYTE *iSrc=info.pImage;
525	for(unsigned long i=0; i < head.biSizeImage; i++){
526	iSrc=(BYTE)~((iSrc));
527	iSrc++;
528	}
529	} else { // RGB with selection
530	RGBQUAD color;
531	for(long y=info.rSelectionBox.bottom; y<info.rSelectionBox.top; y++){
532	for(long x=info.rSelectionBox.left; x<info.rSelectionBox.right; x++){
533	#if CXIMAGE_SUPPORT_SELECTION
534	if (BlindSelectionIsInside(x,y))
535	#endif //CXIMAGE_SUPPORT_SELECTION
536	{
537	color = BlindGetPixelColor(x,y);
538	color.rgbRed = (BYTE)(255-color.rgbRed);
539	color.rgbGreen = (BYTE)(255-color.rgbGreen);
540	color.rgbBlue = (BYTE)(255-color.rgbBlue);
541	BlindSetPixelColor(x,y,color);
542	}
543	}
544	}
545	}
546	//<DP> invert transparent color too
547	info.nBkgndColor.rgbBlue = (BYTE)(255-info.nBkgndColor.rgbBlue);
548	info.nBkgndColor.rgbGreen = (BYTE)(255-info.nBkgndColor.rgbGreen);
549	info.nBkgndColor.rgbRed = (BYTE)(255-info.nBkgndColor.rgbRed);
550	}
551	return true;
552	}
553
554	////////////////////////////////////////////////////////////////////////////////
555	#endif //CXIMAGE_SUPPORT_BASICTRANSFORMATIONS
556	////////////////////////////////////////////////////////////////////////////////
557	#if CXIMAGE_SUPPORT_TRANSFORMATION
558	////////////////////////////////////////////////////////////////////////////////
559
560	////////////////////////////////////////////////////////////////////////////////
561	bool CxImage::Rotate(float angle, CxImage* iDst)
562	{
563	if (!pDib) return false;
564
565	// Copyright (c) 1996-1998 Ulrich von Zadow
566
567	// Negative the angle, because the y-axis is negative.
568	double ang = -angle*acos((float)0)/90;
569	int newWidth, newHeight;
570	int nWidth = GetWidth();
571	int nHeight= GetHeight();
572	double cos_angle = cos(ang);
573	double sin_angle = sin(ang);
574
575	// Calculate the size of the new bitmap
576	POINT p1={0,0};
577	POINT p2={nWidth,0};
578	POINT p3={0,nHeight};
579	POINT p4={nWidth,nHeight};
580	CxPoint2 newP1,newP2,newP3,newP4, leftTop, rightTop, leftBottom, rightBottom;
581
582	newP1.x = (float)p1.x;
583	newP1.y = (float)p1.y;
584	newP2.x = (float)(p2.xcos_angle - p2.ysin_angle);
585	newP2.y = (float)(p2.xsin_angle + p2.ycos_angle);
586	newP3.x = (float)(p3.xcos_angle - p3.ysin_angle);
587	newP3.y = (float)(p3.xsin_angle + p3.ycos_angle);
588	newP4.x = (float)(p4.xcos_angle - p4.ysin_angle);
589	newP4.y = (float)(p4.xsin_angle + p4.ycos_angle);
590
591	leftTop.x = min(min(newP1.x,newP2.x),min(newP3.x,newP4.x));
592	leftTop.y = min(min(newP1.y,newP2.y),min(newP3.y,newP4.y));
593	rightBottom.x = max(max(newP1.x,newP2.x),max(newP3.x,newP4.x));
594	rightBottom.y = max(max(newP1.y,newP2.y),max(newP3.y,newP4.y));
595	leftBottom.x = leftTop.x;
596	leftBottom.y = rightBottom.y;
597	rightTop.x = rightBottom.x;
598	rightTop.y = leftTop.y;
599
600	newWidth = (int) floor(0.5f + rightTop.x - leftTop.x);
601	newHeight= (int) floor(0.5f + leftBottom.y - leftTop.y);
602	CxImage imgDest;
603	imgDest.CopyInfo(*this);
604	imgDest.Create(newWidth,newHeight,GetBpp(),GetType());
605	imgDest.SetPalette(GetPalette());
606
607	#if CXIMAGE_SUPPORT_ALPHA
608	if(AlphaIsValid()) //MTA: Fix for rotation problem when the image has an alpha channel
609	{
610	imgDest.AlphaCreate();
611	imgDest.AlphaClear();
612	}
613	#endif //CXIMAGE_SUPPORT_ALPHA
614
615	int x,y,newX,newY,oldX,oldY;
616
617	if (head.biClrUsed==0){ //RGB
618	for (y = (int)leftTop.y, newY = 0; y<=(int)leftBottom.y; y++,newY++){
619	info.nProgress = (long)(100*newY/newHeight);
620	if (info.nEscape) break;
621	for (x = (int)leftTop.x, newX = 0; x<=(int)rightTop.x; x++,newX++){
622	oldX = (long)(xcos_angle + ysin_angle + 0.5);
623	oldY = (long)(ycos_angle - xsin_angle + 0.5);
624	imgDest.SetPixelColor(newX,newY,GetPixelColor(oldX,oldY));
625	#if CXIMAGE_SUPPORT_ALPHA
626	imgDest.AlphaSet(newX,newY,AlphaGet(oldX,oldY)); //MTA: copy the alpha value
627	#endif //CXIMAGE_SUPPORT_ALPHA
628	}
629	}
630	} else { //PALETTE
631	for (y = (int)leftTop.y, newY = 0; y<=(int)leftBottom.y; y++,newY++){
632	info.nProgress = (long)(100*newY/newHeight);
633	if (info.nEscape) break;
634	for (x = (int)leftTop.x, newX = 0; x<=(int)rightTop.x; x++,newX++){
635	oldX = (long)(xcos_angle + ysin_angle + 0.5);
636	oldY = (long)(ycos_angle - xsin_angle + 0.5);
637	imgDest.SetPixelIndex(newX,newY,GetPixelIndex(oldX,oldY));
638	#if CXIMAGE_SUPPORT_ALPHA
639	imgDest.AlphaSet(newX,newY,AlphaGet(oldX,oldY)); //MTA: copy the alpha value
640	#endif //CXIMAGE_SUPPORT_ALPHA
641	}
642	}
643	}
644	//select the destination
645	if (iDst) iDst->Transfer(imgDest);
646	else Transfer(imgDest);
647
648	return true;
649	}
650	////////////////////////////////////////////////////////////////////////////////
651	/**
652	* Rotates image around it's center.
653	* Method can use interpolation with paletted images, but does not change pallete, so results vary.
654	* (If you have only four colours in a palette, there's not much room for interpolation.)
655	*
656	* \param angle - angle in degrees (positive values rotate clockwise)
657	* \param *iDst - destination image (if null, this image is changed)
658	* \param inMethod - interpolation method used
659	* (IM_NEAREST_NEIGHBOUR produces aliasing (fast), IM_BILINEAR softens picture a bit (slower)
660	* IM_SHARPBICUBIC is slower and produces some halos...)
661	* \param ofMethod - overflow method (how to choose colour of pixels that have no source)
662	* \param replColor - replacement colour to use (OM_COLOR, OM_BACKGROUND with no background colour...)
663	* \param optimizeRightAngles - call faster methods for 90, 180, and 270 degree rotations. Faster methods
664	* are called for angles, where error (in location of corner pixels) is less
665	* than 0.25 pixels.
666	* \param bKeepOriginalSize - rotates the image without resizing.
667	*
668	* \author *bd* 2.2004
669	*/
670	bool CxImage::Rotate2(float angle,
671	CxImage *iDst,
672	InterpolationMethod inMethod,
673	OverflowMethod ofMethod,
674	RGBQUAD *replColor,
675	bool const optimizeRightAngles,
676	bool const bKeepOriginalSize)
677	{
678	if (!pDib) return false; //no dib no go
679
680	double ang = -angle*acos(0.0f)/90.0f; //convert angle to radians and invert (positive angle performs clockwise rotation)
681	float cos_angle = (float) cos(ang); //these two are needed later (to rotate)
682	float sin_angle = (float) sin(ang);
683
684	//Calculate the size of the new bitmap (rotate corners of image)
685	CxPoint2 p[4]; //original corners of the image
686	p[0]=CxPoint2(-0.5f,-0.5f);
687	p[1]=CxPoint2(GetWidth()-0.5f,-0.5f);
688	p[2]=CxPoint2(-0.5f,GetHeight()-0.5f);
689	p[3]=CxPoint2(GetWidth()-0.5f,GetHeight()-0.5f);
690	CxPoint2 newp[4]; //rotated positions of corners
691	//(rotate corners)
692	if (bKeepOriginalSize){
693	for (int i=0; i<4; i++) {
694	newp[i].x = p[i].x;
695	newp[i].y = p[i].y;
696	}//for
697	} else {
698	for (int i=0; i<4; i++) {
699	newp[i].x = (p[i].xcos_angle - p[i].ysin_angle);
700	newp[i].y = (p[i].xsin_angle + p[i].ycos_angle);
701	}//for i
702
703	if (optimizeRightAngles) {
704	//For rotations of 90, -90 or 180 or 0 degrees, call faster routines
705	if (newp[3].Distance(CxPoint2(GetHeight()-0.5f, 0.5f-GetWidth())) < 0.25)
706	//rotation right for circa 90 degrees (diagonal pixels less than 0.25 pixel away from 90 degree rotation destination)
707	return RotateRight(iDst);
708	if (newp[3].Distance(CxPoint2(0.5f-GetHeight(), -0.5f+GetWidth())) < 0.25)
709	//rotation left for ~90 degrees
710	return RotateLeft(iDst);
711	if (newp[3].Distance(CxPoint2(0.5f-GetWidth(), 0.5f-GetHeight())) < 0.25)
712	//rotation left for ~180 degrees
713	return Rotate180(iDst);
714	if (newp[3].Distance(p[3]) < 0.25) {
715	//rotation not significant
716	if (iDst) iDst->Copy(*this); //copy image to iDst, if required
717	return true; //and we're done
718	}//if
719	}//if
720	}//if
721
722	//(read new dimensions from location of corners)
723	float minx = (float) min(min(newp[0].x,newp[1].x),min(newp[2].x,newp[3].x));
724	float miny = (float) min(min(newp[0].y,newp[1].y),min(newp[2].y,newp[3].y));
725	float maxx = (float) max(max(newp[0].x,newp[1].x),max(newp[2].x,newp[3].x));
726	float maxy = (float) max(max(newp[0].y,newp[1].y),max(newp[2].y,newp[3].y));
727	int newWidth = (int) floor(maxx-minx+0.5f);
728	int newHeight= (int) floor(maxy-miny+0.5f);
729	float ssx=((maxx+minx)- ((float) newWidth-1))/2.0f; //start for x
730	float ssy=((maxy+miny)- ((float) newHeight-1))/2.0f; //start for y
731
732	float newxcenteroffset = 0.5f * newWidth;
733	float newycenteroffset = 0.5f * newHeight;
734	if (bKeepOriginalSize){
735	ssx -= 0.5f * GetWidth();
736	ssy -= 0.5f * GetHeight();
737	}
738
739	//create destination image
740	CxImage imgDest;
741	imgDest.CopyInfo(*this);
742	imgDest.Create(newWidth,newHeight,GetBpp(),GetType());
743	imgDest.SetPalette(GetPalette());
744	#if CXIMAGE_SUPPORT_ALPHA
745	if(AlphaIsValid()) imgDest.AlphaCreate(); //MTA: Fix for rotation problem when the image has an alpha channel
746	#endif //CXIMAGE_SUPPORT_ALPHA
747
748	RGBQUAD rgb; //pixel colour
749	RGBQUAD rc;
750	if (replColor!=0)
751	rc=*replColor;
752	else {
753	rc.rgbRed=255; rc.rgbGreen=255; rc.rgbBlue=255; rc.rgbReserved=0;
754	}//if
755	float x,y; //destination location (float, with proper offset)
756	float origx, origy; //origin location
757	int destx, desty; //destination location
758
759	y=ssy; //initialize y
760	if (!IsIndexed()){ //RGB24
761	//optimized RGB24 implementation (direct write to destination):
762	BYTE *pxptr;
763	#if CXIMAGE_SUPPORT_ALPHA
764	BYTE *pxptra=0;
765	#endif //CXIMAGE_SUPPORT_ALPHA
766	for (desty=0; desty<newHeight; desty++) {
767	info.nProgress = (long)(100*desty/newHeight);
768	if (info.nEscape) break;
769	//initialize x
770	x=ssx;
771	//calculate pointer to first byte in row
772	pxptr=(BYTE *)imgDest.BlindGetPixelPointer(0, desty);
773	#if CXIMAGE_SUPPORT_ALPHA
774	//calculate pointer to first byte in row
775	if (AlphaIsValid()) pxptra=imgDest.AlphaGetPointer(0, desty);
776	#endif //CXIMAGE_SUPPORT_ALPHA
777	for (destx=0; destx<newWidth; destx++) {
778	//get source pixel coordinate for current destination point
779	//origx = (cos_angle(x-head.biWidth/2)+sin_angle(y-head.biHeight/2))+newWidth/2;
780	//origy = (cos_angle(y-head.biHeight/2)-sin_angle(x-head.biWidth/2))+newHeight/2;
781	origx = cos_anglex+sin_angley;
782	origy = cos_angley-sin_anglex;
783	if (bKeepOriginalSize){
784	origx += newxcenteroffset;
785	origy += newycenteroffset;
786	}
787	rgb = GetPixelColorInterpolated(origx, origy, inMethod, ofMethod, &rc); //get interpolated colour value
788	//copy alpha and colour value to destination
789	#if CXIMAGE_SUPPORT_ALPHA
790	if (pxptra) *pxptra++ = rgb.rgbReserved;
791	#endif //CXIMAGE_SUPPORT_ALPHA
792	*pxptr++ = rgb.rgbBlue;
793	*pxptr++ = rgb.rgbGreen;
794	*pxptr++ = rgb.rgbRed;
795	x++;
796	}//for destx
797	y++;
798	}//for desty
799	} else {
800	//non-optimized implementation for paletted images
801	for (desty=0; desty<newHeight; desty++) {
802	info.nProgress = (long)(100*desty/newHeight);
803	if (info.nEscape) break;
804	x=ssx;
805	for (destx=0; destx<newWidth; destx++) {
806	//get source pixel coordinate for current destination point
807	origx=(cos_anglex+sin_angley);
808	origy=(cos_angley-sin_anglex);
809	if (bKeepOriginalSize){
810	origx += newxcenteroffset;
811	origy += newycenteroffset;
812	}
813	rgb = GetPixelColorInterpolated(origx, origy, inMethod, ofMethod, &rc);
814	//*!* SetPixelColor is slow for palleted images
815	#if CXIMAGE_SUPPORT_ALPHA
816	if (AlphaIsValid())
817	imgDest.SetPixelColor(destx,desty,rgb,true);
818	else
819	#endif //CXIMAGE_SUPPORT_ALPHA
820	imgDest.SetPixelColor(destx,desty,rgb,false);
821	x++;
822	}//for destx
823	y++;
824	}//for desty
825	}
826	//select the destination
827
828	if (iDst) iDst->Transfer(imgDest);
829	else Transfer(imgDest);
830
831	return true;
832	}
833	////////////////////////////////////////////////////////////////////////////////
834	bool CxImage::Rotate180(CxImage* iDst)
835	{
836	if (!pDib) return false;
837
838	long wid = GetWidth();
839	long ht = GetHeight();
840
841	CxImage imgDest;
842	imgDest.CopyInfo(*this);
843	imgDest.Create(wid,ht,GetBpp(),GetType());
844	imgDest.SetPalette(GetPalette());
845
846	#if CXIMAGE_SUPPORT_ALPHA
847	if (AlphaIsValid()) imgDest.AlphaCreate();
848	#endif //CXIMAGE_SUPPORT_ALPHA
849
850	long x,y,y2;
851	for (y = 0; y < ht; y++){
852	info.nProgress = (long)(100*y/ht); //<Anatoly Ivasyuk>
853	y2=ht-y-1;
854	for (x = 0; x < wid; x++){
855	if(head.biClrUsed==0)//RGB
856	imgDest.SetPixelColor(wid-x-1, y2, BlindGetPixelColor(x, y));
857	else //PALETTE
858	imgDest.SetPixelIndex(wid-x-1, y2, BlindGetPixelIndex(x, y));
859
860	#if CXIMAGE_SUPPORT_ALPHA
861	if (AlphaIsValid()) imgDest.AlphaSet(wid-x-1, y2,BlindAlphaGet(x, y));
862	#endif //CXIMAGE_SUPPORT_ALPHA
863
864	}
865	}
866
867	//select the destination
868	if (iDst) iDst->Transfer(imgDest);
869	else Transfer(imgDest);
870	return true;
871	}
872
873	////////////////////////////////////////////////////////////////////////////////
874	/**
875	* Resizes the image. mode can be 0 for slow (bilinear) method ,
876	* 1 for fast (nearest pixel) method, or 2 for accurate (bicubic spline interpolation) method.
877	* The function is faster with 24 and 1 bpp images, slow for 4 bpp images and slowest for 8 bpp images.
878	*/
879	bool CxImage::Resample(long newx, long newy, int mode, CxImage* iDst)
880	{
881	if (newx==0 \|\| newy==0) return false;
882
883	if (head.biWidth==newx && head.biHeight==newy){
884	if (iDst) iDst->Copy(*this);
885	return true;
886	}
887
888	float xScale, yScale, fX, fY;
889	xScale = (float)head.biWidth / (float)newx;
890	yScale = (float)head.biHeight / (float)newy;
891
892	CxImage newImage;
893	newImage.CopyInfo(*this);
894	newImage.Create(newx,newy,head.biBitCount,GetType());
895	newImage.SetPalette(GetPalette());
896	if (!newImage.IsValid()){
897	strcpy(info.szLastError,newImage.GetLastError());
898	return false;
899	}
900
901	switch (mode) {
902	case 1: // nearest pixel
903	{
904	for(long y=0; y<newy; y++){
905	info.nProgress = (long)(100*y/newy);
906	if (info.nEscape) break;
907	fY = y * yScale;
908	for(long x=0; x<newx; x++){
909	fX = x * xScale;
910	newImage.SetPixelColor(x,y,GetPixelColor((long)fX,(long)fY));
911	}
912	}
913	break;
914	}
915	case 2: // bicubic interpolation by Blake L. Carlson <blake-carlson(at)uiowa(dot)edu
916	{
917	float f_x, f_y, a, b, rr, gg, bb, r1, r2;
918	int i_x, i_y, xx, yy;
919	RGBQUAD rgb;
920	BYTE* iDst;
921	for(long y=0; y<newy; y++){
922	info.nProgress = (long)(100*y/newy);
923	if (info.nEscape) break;
924	f_y = (float) y * yScale - 0.5f;
925	i_y = (int) floor(f_y);
926	a = f_y - (float)floor(f_y);
927	for(long x=0; x<newx; x++){
928	f_x = (float) x * xScale - 0.5f;
929	i_x = (int) floor(f_x);
930	b = f_x - (float)floor(f_x);
931
932	rr = gg = bb = 0.0f;
933	for(int m=-1; m<3; m++) {
934	r1 = KernelBSpline((float) m - a);
935	yy = i_y+m;
936	if (yy<0) yy=0;
937	if (yy>=head.biHeight) yy = head.biHeight-1;
938	for(int n=-1; n<3; n++) {
939	r2 = r1 * KernelBSpline(b - (float)n);
940	xx = i_x+n;
941	if (xx<0) xx=0;
942	if (xx>=head.biWidth) xx=head.biWidth-1;
943
944	if (head.biClrUsed){
945	rgb = GetPixelColor(xx,yy);
946	} else {
947	iDst = info.pImage + yyinfo.dwEffWidth + xx3;
948	rgb.rgbBlue = *iDst++;
949	rgb.rgbGreen= *iDst++;
950	rgb.rgbRed = *iDst;
951	}
952
953	rr += rgb.rgbRed * r2;
954	gg += rgb.rgbGreen * r2;
955	bb += rgb.rgbBlue * r2;
956	}
957	}
958
959	if (head.biClrUsed)
960	newImage.SetPixelColor(x,y,RGB(rr,gg,bb));
961	else {
962	iDst = newImage.info.pImage + ynewImage.info.dwEffWidth + x3;
963	*iDst++ = (BYTE)bb;
964	*iDst++ = (BYTE)gg;
965	*iDst = (BYTE)rr;
966	}
967
968	}
969	}
970	break;
971	}
972	default: // bilinear interpolation
973	if (!(head.biWidth>newx && head.biHeight>newy && head.biBitCount==24)) {
974	// (c) 1999 Steve McMahon (steve@dogma.demon.co.uk)
975	long ifX, ifY, ifX1, ifY1, xmax, ymax;
976	float ir1, ir2, ig1, ig2, ib1, ib2, dx, dy;
977	BYTE r,g,b;
978	RGBQUAD rgb1, rgb2, rgb3, rgb4;
979	xmax = head.biWidth-1;
980	ymax = head.biHeight-1;
981	for(long y=0; y<newy; y++){
982	info.nProgress = (long)(100*y/newy);
983	if (info.nEscape) break;
984	fY = y * yScale;
985	ifY = (int)fY;
986	ifY1 = min(ymax, ifY+1);
987	dy = fY - ifY;
988	for(long x=0; x<newx; x++){
989	fX = x * xScale;
990	ifX = (int)fX;
991	ifX1 = min(xmax, ifX+1);
992	dx = fX - ifX;
993	// Interpolate using the four nearest pixels in the source
994	if (head.biClrUsed){
995	rgb1=GetPaletteColor(GetPixelIndex(ifX,ifY));
996	rgb2=GetPaletteColor(GetPixelIndex(ifX1,ifY));
997	rgb3=GetPaletteColor(GetPixelIndex(ifX,ifY1));
998	rgb4=GetPaletteColor(GetPixelIndex(ifX1,ifY1));
999	}
1000	else {
1001	BYTE* iDst;
1002	iDst = info.pImage + ifYinfo.dwEffWidth + ifX3;
1003	rgb1.rgbBlue = iDst++; rgb1.rgbGreen= iDst++; rgb1.rgbRed =*iDst;
1004	iDst = info.pImage + ifYinfo.dwEffWidth + ifX13;
1005	rgb2.rgbBlue = iDst++; rgb2.rgbGreen= iDst++; rgb2.rgbRed =*iDst;
1006	iDst = info.pImage + ifY1info.dwEffWidth + ifX3;
1007	rgb3.rgbBlue = iDst++; rgb3.rgbGreen= iDst++; rgb3.rgbRed =*iDst;
1008	iDst = info.pImage + ifY1info.dwEffWidth + ifX13;
1009	rgb4.rgbBlue = iDst++; rgb4.rgbGreen= iDst++; rgb4.rgbRed =*iDst;
1010	}
1011	// Interplate in x direction:
1012	ir1 = rgb1.rgbRed + (rgb3.rgbRed - rgb1.rgbRed) * dy;
1013	ig1 = rgb1.rgbGreen + (rgb3.rgbGreen - rgb1.rgbGreen) * dy;
1014	ib1 = rgb1.rgbBlue + (rgb3.rgbBlue - rgb1.rgbBlue) * dy;
1015	ir2 = rgb2.rgbRed + (rgb4.rgbRed - rgb2.rgbRed) * dy;
1016	ig2 = rgb2.rgbGreen + (rgb4.rgbGreen - rgb2.rgbGreen) * dy;
1017	ib2 = rgb2.rgbBlue + (rgb4.rgbBlue - rgb2.rgbBlue) * dy;
1018	// Interpolate in y:
1019	r = (BYTE)(ir1 + (ir2-ir1) * dx);
1020	g = (BYTE)(ig1 + (ig2-ig1) * dx);
1021	b = (BYTE)(ib1 + (ib2-ib1) * dx);
1022	// Set output
1023	newImage.SetPixelColor(x,y,RGB(r,g,b));
1024	}
1025	}
1026	} else {
1027	//high resolution shrink, thanks to Henrik Stellmann <henrik.stellmann@volleynet.de>
1028	const long ACCURACY = 1000;
1029	long i,j; // index for faValue
1030	long x,y; // coordinates in source image
1031	BYTE* pSource;
1032	BYTE* pDest = newImage.info.pImage;
1033	long* naAccu = new long[3 * newx + 3];
1034	long* naCarry = new long[3 * newx + 3];
1035	long* naTemp;
1036	long nWeightX,nWeightY;
1037	float fEndX;
1038	long nScale = (long)(ACCURACY * xScale * yScale);
1039
1040	memset(naAccu, 0, sizeof(long) * 3 * newx);
1041	memset(naCarry, 0, sizeof(long) * 3 * newx);
1042
1043	int u, v = 0; // coordinates in dest image
1044	float fEndY = yScale - 1.0f;
1045	for (y = 0; y < head.biHeight; y++){
1046	info.nProgress = (long)(100*y/head.biHeight); //<Anatoly Ivasyuk>
1047	if (info.nEscape) break;
1048	pSource = info.pImage + y * info.dwEffWidth;
1049	u = i = 0;
1050	fEndX = xScale - 1.0f;
1051	if ((float)y < fEndY) { // complete source row goes into dest row
1052	for (x = 0; x < head.biWidth; x++){
1053	if ((float)x < fEndX){ // complete source pixel goes into dest pixel
1054	for (j = 0; j < 3; j++) naAccu[i + j] += (pSource++) ACCURACY;
1055	} else { // source pixel is splitted for 2 dest pixels
1056	nWeightX = (long)(((float)x - fEndX) * ACCURACY);
1057	for (j = 0; j < 3; j++){
1058	naAccu[i] += (ACCURACY - nWeightX) * (*pSource);
1059	naAccu[3 + i++] += nWeightX * (*pSource++);
1060	}
1061	fEndX += xScale;
1062	u++;
1063	}
1064	}
1065	} else { // source row is splitted for 2 dest rows
1066	nWeightY = (long)(((float)y - fEndY) * ACCURACY);
1067	for (x = 0; x < head.biWidth; x++){
1068	if ((float)x < fEndX){ // complete source pixel goes into 2 pixel
1069	for (j = 0; j < 3; j++){
1070	naAccu[i + j] += ((ACCURACY - nWeightY) * (*pSource));
1071	naCarry[i + j] += nWeightY * (*pSource++);
1072	}
1073	} else { // source pixel is splitted for 4 dest pixels
1074	nWeightX = (int)(((float)x - fEndX) * ACCURACY);
1075	for (j = 0; j < 3; j++) {
1076	naAccu[i] += ((ACCURACY - nWeightY) * (ACCURACY - nWeightX)) * (*pSource) / ACCURACY;
1077	*pDest++ = (BYTE)(naAccu[i] / nScale);
1078	naCarry[i] += (nWeightY * (ACCURACY - nWeightX) * (*pSource)) / ACCURACY;
1079	naAccu[i + 3] += ((ACCURACY - nWeightY) * nWeightX * (*pSource)) / ACCURACY;
1080	naCarry[i + 3] = (nWeightY * nWeightX * (*pSource)) / ACCURACY;
1081	i++;
1082	pSource++;
1083	}
1084	fEndX += xScale;
1085	u++;
1086	}
1087	}
1088	if (u < newx){ // possibly not completed due to rounding errors
1089	for (j = 0; j < 3; j++) *pDest++ = (BYTE)(naAccu[i++] / nScale);
1090	}
1091	naTemp = naCarry;
1092	naCarry = naAccu;
1093	naAccu = naTemp;
1094	memset(naCarry, 0, sizeof(int) * 3); // need only to set first pixel zero
1095	pDest = newImage.info.pImage + (++v * newImage.info.dwEffWidth);
1096	fEndY += yScale;
1097	}
1098	}
1099	if (v < newy){ // possibly not completed due to rounding errors
1100	for (i = 0; i < 3 * newx; i++) *pDest++ = (BYTE)(naAccu[i] / nScale);
1101	}
1102	delete [] naAccu;
1103	delete [] naCarry;
1104	}
1105	}
1106
1107	#if CXIMAGE_SUPPORT_ALPHA
1108	if (AlphaIsValid()){
1109	newImage.AlphaCreate();
1110	for(long y=0; y<newy; y++){
1111	fY = y * yScale;
1112	for(long x=0; x<newx; x++){
1113	fX = x * xScale;
1114	newImage.AlphaSet(x,y,AlphaGet((long)fX,(long)fY));
1115	}
1116	}
1117	}
1118	#endif //CXIMAGE_SUPPORT_ALPHA
1119
1120	//select the destination
1121	if (iDst) iDst->Transfer(newImage);
1122	else Transfer(newImage);
1123
1124	return true;
1125	}
1126	////////////////////////////////////////////////////////////////////////////////
1127	/**
1128	* New simpler resample. Adds new interpolation methods and simplifies code (using GetPixelColorInterpolated
1129	* and GetAreaColorInterpolated). It also (unlike old method) interpolates alpha layer.
1130	*
1131	* \param newx, newy - size of resampled image
1132	* \param inMethod - interpolation method to use (see comments at GetPixelColorInterpolated)
1133	* If image size is being reduced, averaging is used instead (or simultaneously with) inMethod.
1134	* \param ofMethod - what to replace outside pixels by (only significant for bordering pixels of enlarged image)
1135	* \param iDst - pointer to destination CxImage or NULL.
1136	* \param disableAveraging - force no averaging when shrinking images (Produces aliasing.
1137	* You probably just want to leave this off...)
1138	*
1139	* \author *bd* 2.2004
1140	*/
1141	bool CxImage::Resample2(
1142	long newx, long newy,
1143	InterpolationMethod const inMethod,
1144	OverflowMethod const ofMethod,
1145	CxImage* const iDst,
1146	bool const disableAveraging)
1147	{
1148	if (newx<=0 \|\| newy<=0 \|\| !pDib) return false;
1149
1150	if (head.biWidth==newx && head.biHeight==newy) {
1151	//image already correct size (just copy and return)
1152	if (iDst) iDst->Copy(*this);
1153	return true;
1154	}//if
1155
1156	//calculate scale of new image (less than 1 for enlarge)
1157	float xScale, yScale;
1158	xScale = (float)head.biWidth / (float)newx;
1159	yScale = (float)head.biHeight / (float)newy;
1160
1161	//create temporary destination image
1162	CxImage newImage;
1163	newImage.CopyInfo(*this);
1164	newImage.Create(newx,newy,head.biBitCount,GetType());
1165	newImage.SetPalette(GetPalette());
1166	if (!newImage.IsValid()){
1167	strcpy(info.szLastError,newImage.GetLastError());
1168	return false;
1169	}
1170
1171	//and alpha channel if required
1172	#if CXIMAGE_SUPPORT_ALPHA
1173	if (AlphaIsValid()) newImage.AlphaCreate();
1174	BYTE *pxptra = 0; // destination alpha data
1175	#endif
1176
1177	float sX, sY; //source location
1178	long dX,dY; //destination pixel (int value)
1179	if ((xScale<=1 && yScale<=1) \|\| disableAveraging) {
1180	//image is being enlarged (or interpolation on demand)
1181	if (!IsIndexed()) {
1182	//RGB24 image (optimized version with direct writes)
1183	RGBQUAD q; //pixel colour
1184	BYTE *pxptr; //pointer to destination pixel
1185	for(dY=0; dY<newy; dY++){
1186	info.nProgress = (long)(100*dY/newy);
1187	if (info.nEscape) break;
1188	sY = (dY + 0.5f) * yScale - 0.5f;
1189	pxptr=(BYTE*)(newImage.BlindGetPixelPointer(0,dY));
1190	#if CXIMAGE_SUPPORT_ALPHA
1191	pxptra=newImage.AlphaGetPointer(0,dY);
1192	#endif
1193	for(dX=0; dX<newx; dX++){
1194	sX = (dX + 0.5f) * xScale - 0.5f;
1195	q=GetPixelColorInterpolated(sX,sY,inMethod,ofMethod,0);
1196	*pxptr++=q.rgbBlue;
1197	*pxptr++=q.rgbGreen;
1198	*pxptr++=q.rgbRed;
1199	#if CXIMAGE_SUPPORT_ALPHA
1200	if (pxptra) *pxptra++=q.rgbReserved;
1201	#endif
1202	}//for dX
1203	}//for dY
1204	} else {
1205	//enlarge paletted image. Slower method.
1206	for(dY=0; dY<newy; dY++){
1207	info.nProgress = (long)(100*dY/newy);
1208	if (info.nEscape) break;
1209	sY = (dY + 0.5f) * yScale - 0.5f;
1210	for(dX=0; dX<newx; dX++){
1211	sX = (dX + 0.5f) * xScale - 0.5f;
1212	newImage.SetPixelColor(dX,dY,GetPixelColorInterpolated(sX,sY,inMethod,ofMethod,0),true);
1213	}//for x
1214	}//for y
1215	}//if
1216	} else {
1217	//image size is being reduced (averaging enabled)
1218	for(dY=0; dY<newy; dY++){
1219	info.nProgress = (long)(100*dY/newy); if (info.nEscape) break;
1220	sY = (dY+0.5f) * yScale - 0.5f;
1221	for(dX=0; dX<newx; dX++){
1222	sX = (dX+0.5f) * xScale - 0.5f;
1223	newImage.SetPixelColor(dX,dY,GetAreaColorInterpolated(sX, sY, xScale, yScale, inMethod, ofMethod,0),true);
1224	}//for x
1225	}//for y
1226	}//if
1227
1228	#if CXIMAGE_SUPPORT_ALPHA
1229	if (AlphaIsValid() && pxptra == 0){
1230	for(long y=0; y<newy; y++){
1231	dY = (long)(y * yScale);
1232	for(long x=0; x<newx; x++){
1233	dX = (long)(x * xScale);
1234	newImage.AlphaSet(x,y,AlphaGet(dX,dY));
1235	}
1236	}
1237	}
1238	#endif //CXIMAGE_SUPPORT_ALPHA
1239
1240	//copy new image to the destination
1241	if (iDst)
1242	iDst->Transfer(newImage);
1243	else
1244	Transfer(newImage);
1245	return true;
1246	}
1247	////////////////////////////////////////////////////////////////////////////////
1248	/**
1249	* Reduces the number of bits per pixel to nbit (1, 4 or 8).
1250	* ppal points to a valid palette for the final image; if not supplied the function will use a standard palette.
1251	* ppal is not necessary for reduction to 1 bpp.
1252	*/
1253	bool CxImage::DecreaseBpp(DWORD nbit, bool errordiffusion, RGBQUAD* ppal, DWORD clrimportant)
1254	{
1255	if (!pDib) return false;
1256	if (head.biBitCount < nbit){
1257	strcpy(info.szLastError,"DecreaseBpp: target BPP greater than source BPP");
1258	return false;
1259	}
1260	if (head.biBitCount == nbit){
1261	if (clrimportant==0) return true;
1262	if (head.biClrImportant && (head.biClrImportant<clrimportant)) return true;
1263	}
1264
1265	long er,eg,eb;
1266	RGBQUAD c,ce;
1267
1268	CxImage tmp;
1269	tmp.CopyInfo(*this);
1270	tmp.Create(head.biWidth,head.biHeight,(WORD)nbit,info.dwType);
1271	if (clrimportant) tmp.SetClrImportant(clrimportant);
1272	if (!tmp.IsValid()){
1273	strcpy(info.szLastError,tmp.GetLastError());
1274	return false;
1275	}
1276
1277	#if CXIMAGE_SUPPORT_SELECTION
1278	tmp.SelectionCopy(*this);
1279	#endif //CXIMAGE_SUPPORT_SELECTION
1280
1281	#if CXIMAGE_SUPPORT_ALPHA
1282	tmp.AlphaCopy(*this);
1283	#endif //CXIMAGE_SUPPORT_ALPHA
1284
1285	if (ppal) {
1286	if (clrimportant) {
1287	tmp.SetPalette(ppal,clrimportant);
1288	} else {
1289	tmp.SetPalette(ppal,1<<tmp.head.biBitCount);
1290	}
1291	} else {
1292	tmp.SetStdPalette();
1293	}
1294
1295	for (long y=0;y<head.biHeight;y++){
1296	if (info.nEscape) break;
1297	info.nProgress = (long)(100*y/head.biHeight);
1298	for (long x=0;x<head.biWidth;x++){
1299	if (!errordiffusion){
1300	tmp.BlindSetPixelColor(x,y,BlindGetPixelColor(x,y));
1301	} else {
1302	c = BlindGetPixelColor(x,y);
1303	tmp.BlindSetPixelColor(x,y,c);
1304
1305	ce = tmp.BlindGetPixelColor(x,y);
1306	er=(long)c.rgbRed - (long)ce.rgbRed;
1307	eg=(long)c.rgbGreen - (long)ce.rgbGreen;
1308	eb=(long)c.rgbBlue - (long)ce.rgbBlue;
1309
1310	c = GetPixelColor(x+1,y);
1311	c.rgbRed = (BYTE)min(255L,max(0L,(long)c.rgbRed + ((er*7)/16)));
1312	c.rgbGreen = (BYTE)min(255L,max(0L,(long)c.rgbGreen + ((eg*7)/16)));
1313	c.rgbBlue = (BYTE)min(255L,max(0L,(long)c.rgbBlue + ((eb*7)/16)));
1314	SetPixelColor(x+1,y,c);
1315	int coeff=1;
1316	for(int i=-1; i<2; i++){
1317	switch(i){
1318	case -1:
1319	coeff=2; break;
1320	case 0:
1321	coeff=4; break;
1322	case 1:
1323	coeff=1; break;
1324	}
1325	c = GetPixelColor(x+i,y+1);
1326	c.rgbRed = (BYTE)min(255L,max(0L,(long)c.rgbRed + ((er * coeff)/16)));
1327	c.rgbGreen = (BYTE)min(255L,max(0L,(long)c.rgbGreen + ((eg * coeff)/16)));
1328	c.rgbBlue = (BYTE)min(255L,max(0L,(long)c.rgbBlue + ((eb * coeff)/16)));
1329	SetPixelColor(x+i,y+1,c);
1330	}
1331	}
1332	}
1333	}
1334
1335	Transfer(tmp);
1336	return true;
1337	}
1338	////////////////////////////////////////////////////////////////////////////////
1339	/**
1340	* Increases the number of bits per pixel of the image.
1341	* \param nbit: 4, 8, 24
1342	*/
1343	bool CxImage::IncreaseBpp(DWORD nbit)
1344	{
1345	if (!pDib) return false;
1346	switch (nbit){
1347	case 4:
1348	{
1349	if (head.biBitCount==4) return true;
1350	if (head.biBitCount>4) return false;
1351
1352	CxImage tmp;
1353	tmp.CopyInfo(*this);
1354	tmp.Create(head.biWidth,head.biHeight,4,info.dwType);
1355	tmp.SetPalette(GetPalette(),GetNumColors());
1356	if (!tmp.IsValid()){
1357	strcpy(info.szLastError,tmp.GetLastError());
1358	return false;
1359	}
1360
1361
1362	#if CXIMAGE_SUPPORT_SELECTION
1363	tmp.SelectionCopy(*this);
1364	#endif //CXIMAGE_SUPPORT_SELECTION
1365
1366	#if CXIMAGE_SUPPORT_ALPHA
1367	tmp.AlphaCopy(*this);
1368	#endif //CXIMAGE_SUPPORT_ALPHA
1369
1370	for (long y=0;y<head.biHeight;y++){
1371	if (info.nEscape) break;
1372	for (long x=0;x<head.biWidth;x++){
1373	tmp.BlindSetPixelIndex(x,y,BlindGetPixelIndex(x,y));
1374	}
1375	}
1376	Transfer(tmp);
1377	return true;
1378	}
1379	case 8:
1380	{
1381	if (head.biBitCount==8) return true;
1382	if (head.biBitCount>8) return false;
1383
1384	CxImage tmp;
1385	tmp.CopyInfo(*this);
1386	tmp.Create(head.biWidth,head.biHeight,8,info.dwType);
1387	tmp.SetPalette(GetPalette(),GetNumColors());
1388	if (!tmp.IsValid()){
1389	strcpy(info.szLastError,tmp.GetLastError());
1390	return false;
1391	}
1392
1393	#if CXIMAGE_SUPPORT_SELECTION
1394	tmp.SelectionCopy(*this);
1395	#endif //CXIMAGE_SUPPORT_SELECTION
1396
1397	#if CXIMAGE_SUPPORT_ALPHA
1398	tmp.AlphaCopy(*this);
1399	#endif //CXIMAGE_SUPPORT_ALPHA
1400
1401	for (long y=0;y<head.biHeight;y++){
1402	if (info.nEscape) break;
1403	for (long x=0;x<head.biWidth;x++){
1404	tmp.BlindSetPixelIndex(x,y,BlindGetPixelIndex(x,y));
1405	}
1406	}
1407	Transfer(tmp);
1408	return true;
1409	}
1410	case 24:
1411	{
1412	if (head.biBitCount==24) return true;
1413	if (head.biBitCount>24) return false;
1414
1415	CxImage tmp;
1416	tmp.CopyInfo(*this);
1417	tmp.Create(head.biWidth,head.biHeight,24,info.dwType);
1418	if (!tmp.IsValid()){
1419	strcpy(info.szLastError,tmp.GetLastError());
1420	return false;
1421	}
1422
1423	if (info.nBkgndIndex>=0) //translate transparency
1424	tmp.info.nBkgndColor=GetPaletteColor((BYTE)info.nBkgndIndex);
1425
1426	#if CXIMAGE_SUPPORT_SELECTION
1427	tmp.SelectionCopy(*this);
1428	#endif //CXIMAGE_SUPPORT_SELECTION
1429
1430	#if CXIMAGE_SUPPORT_ALPHA
1431	tmp.AlphaCopy(*this);
1432	if (AlphaPaletteIsValid() && !AlphaIsValid()) tmp.AlphaCreate();
1433	#endif //CXIMAGE_SUPPORT_ALPHA
1434
1435	for (long y=0;y<head.biHeight;y++){
1436	if (info.nEscape) break;
1437	for (long x=0;x<head.biWidth;x++){
1438	tmp.BlindSetPixelColor(x,y,BlindGetPixelColor(x,y),true);
1439	}
1440	}
1441	Transfer(tmp);
1442	return true;
1443	}
1444	}
1445	return false;
1446	}
1447	////////////////////////////////////////////////////////////////////////////////
1448	/**
1449	* Converts the image to B&W using the desired method :
1450	* - 0 = Floyd-Steinberg
1451	* - 1 = Ordered-Dithering (4x4)
1452	* - 2 = Burkes
1453	* - 3 = Stucki
1454	* - 4 = Jarvis-Judice-Ninke
1455	* - 5 = Sierra
1456	* - 6 = Stevenson-Arce
1457	* - 7 = Bayer (4x4 ordered dithering)
1458	*/
1459	bool CxImage::Dither(long method)
1460	{
1461	if (!pDib) return false;
1462	if (head.biBitCount == 1) return true;
1463
1464	GrayScale();
1465
1466	CxImage tmp;
1467	tmp.CopyInfo(*this);
1468	tmp.Create(head.biWidth, head.biHeight, 1, info.dwType);
1469	if (!tmp.IsValid()){
1470	strcpy(info.szLastError,tmp.GetLastError());
1471	return false;
1472	}
1473
1474	#if CXIMAGE_SUPPORT_SELECTION
1475	tmp.SelectionCopy(*this);
1476	#endif //CXIMAGE_SUPPORT_SELECTION
1477
1478	#if CXIMAGE_SUPPORT_ALPHA
1479	tmp.AlphaCopy(*this);
1480	#endif //CXIMAGE_SUPPORT_ALPHA
1481
1482	switch (method){
1483	case 1:
1484	{
1485	// Multi-Level Ordered-Dithering by Kenny Hoff (Oct. 12, 1995)
1486	#define dth_NumRows 4
1487	#define dth_NumCols 4
1488	#define dth_NumIntensityLevels 2
1489	#define dth_NumRowsLessOne (dth_NumRows-1)
1490	#define dth_NumColsLessOne (dth_NumCols-1)
1491	#define dth_RowsXCols (dth_NumRows*dth_NumCols)
1492	#define dth_MaxIntensityVal 255
1493	#define dth_MaxDitherIntensityVal (dth_NumRowsdth_NumCols(dth_NumIntensityLevels-1))
1494
1495	int DitherMatrix[dth_NumRows][dth_NumCols] = {{0,8,2,10}, {12,4,14,6}, {3,11,1,9}, {15,7,13,5} };
1496
1497	unsigned char Intensity[dth_NumIntensityLevels] = { 0,1 }; // 2 LEVELS B/W
1498	//unsigned char Intensity[NumIntensityLevels] = { 0,255 }; // 2 LEVELS
1499	//unsigned char Intensity[NumIntensityLevels] = { 0,127,255 }; // 3 LEVELS
1500	//unsigned char Intensity[NumIntensityLevels] = { 0,85,170,255 }; // 4 LEVELS
1501	//unsigned char Intensity[NumIntensityLevels] = { 0,63,127,191,255 }; // 5 LEVELS
1502	//unsigned char Intensity[NumIntensityLevels] = { 0,51,102,153,204,255 }; // 6 LEVELS
1503	//unsigned char Intensity[NumIntensityLevels] = { 0,42,85,127,170,213,255 }; // 7 LEVELS
1504	//unsigned char Intensity[NumIntensityLevels] = { 0,36,73,109,145,182,219,255 }; // 8 LEVELS
1505	int DitherIntensity, DitherMatrixIntensity, Offset, DeviceIntensity;
1506	unsigned char DitherValue;
1507
1508	for (long y=0;y<head.biHeight;y++){
1509	info.nProgress = (long)(100*y/head.biHeight);
1510	if (info.nEscape) break;
1511	for (long x=0;x<head.biWidth;x++){
1512
1513	DeviceIntensity = BlindGetPixelIndex(x,y);
1514	DitherIntensity = DeviceIntensity*dth_MaxDitherIntensityVal/dth_MaxIntensityVal;
1515	DitherMatrixIntensity = DitherIntensity % dth_RowsXCols;
1516	Offset = DitherIntensity / dth_RowsXCols;
1517	if (DitherMatrix[y&dth_NumRowsLessOne][x&dth_NumColsLessOne] < DitherMatrixIntensity)
1518	DitherValue = Intensity[1+Offset];
1519	else
1520	DitherValue = Intensity[0+Offset];
1521
1522	tmp.BlindSetPixelIndex(x,y,DitherValue);
1523	}
1524	}
1525	break;
1526	}
1527	case 2:
1528	{
1529	//Burkes error diffusion (Thanks to Franco Gerevini)
1530	int TotalCoeffSum = 32;
1531	long error, nlevel, coeff=1;
1532	BYTE level;
1533
1534	for (long y = 0; y < head.biHeight; y++) {
1535	info.nProgress = (long)(100 * y / head.biHeight);
1536	if (info.nEscape)
1537	break;
1538	for (long x = 0; x < head.biWidth; x++) {
1539	level = BlindGetPixelIndex(x, y);
1540	if (level > 128) {
1541	tmp.SetPixelIndex(x, y, 1);
1542	error = level - 255;
1543	} else {
1544	tmp.SetPixelIndex(x, y, 0);
1545	error = level;
1546	}
1547
1548	nlevel = GetPixelIndex(x + 1, y) + (error * 8) / TotalCoeffSum;
1549	level = (BYTE)min(255, max(0, (int)nlevel));
1550	SetPixelIndex(x + 1, y, level);
1551	nlevel = GetPixelIndex(x + 2, y) + (error * 4) / TotalCoeffSum;
1552	level = (BYTE)min(255, max(0, (int)nlevel));
1553	SetPixelIndex(x + 2, y, level);
1554	int i;
1555	for (i = -2; i < 3; i++) {
1556	switch (i) {
1557	case -2:
1558	coeff = 2;
1559	break;
1560	case -1:
1561	coeff = 4;
1562	break;
1563	case 0:
1564	coeff = 8;
1565	break;
1566	case 1:
1567	coeff = 4;
1568	break;
1569	case 2:
1570	coeff = 2;
1571	break;
1572	}
1573	nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
1574	level = (BYTE)min(255, max(0, (int)nlevel));
1575	SetPixelIndex(x + i, y + 1, level);
1576	}
1577	}
1578	}
1579	break;
1580	}
1581	case 3:
1582	{
1583	//Stucki error diffusion (Thanks to Franco Gerevini)
1584	int TotalCoeffSum = 42;
1585	long error, nlevel, coeff=1;
1586	BYTE level;
1587
1588	for (long y = 0; y < head.biHeight; y++) {
1589	info.nProgress = (long)(100 * y / head.biHeight);
1590	if (info.nEscape)
1591	break;
1592	for (long x = 0; x < head.biWidth; x++) {
1593	level = BlindGetPixelIndex(x, y);
1594	if (level > 128) {
1595	tmp.SetPixelIndex(x, y, 1);
1596	error = level - 255;
1597	} else {
1598	tmp.SetPixelIndex(x, y, 0);
1599	error = level;
1600	}
1601
1602	nlevel = GetPixelIndex(x + 1, y) + (error * 8) / TotalCoeffSum;
1603	level = (BYTE)min(255, max(0, (int)nlevel));
1604	SetPixelIndex(x + 1, y, level);
1605	nlevel = GetPixelIndex(x + 2, y) + (error * 4) / TotalCoeffSum;
1606	level = (BYTE)min(255, max(0, (int)nlevel));
1607	SetPixelIndex(x + 2, y, level);
1608	int i;
1609	for (i = -2; i < 3; i++) {
1610	switch (i) {
1611	case -2:
1612	coeff = 2;
1613	break;
1614	case -1:
1615	coeff = 4;
1616	break;
1617	case 0:
1618	coeff = 8;
1619	break;
1620	case 1:
1621	coeff = 4;
1622	break;
1623	case 2:
1624	coeff = 2;
1625	break;
1626	}
1627	nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
1628	level = (BYTE)min(255, max(0, (int)nlevel));
1629	SetPixelIndex(x + i, y + 1, level);
1630	}
1631	for (i = -2; i < 3; i++) {
1632	switch (i) {
1633	case -2:
1634	coeff = 1;
1635	break;
1636	case -1:
1637	coeff = 2;
1638	break;
1639	case 0:
1640	coeff = 4;
1641	break;
1642	case 1:
1643	coeff = 2;
1644	break;
1645	case 2:
1646	coeff = 1;
1647	break;
1648	}
1649	nlevel = GetPixelIndex(x + i, y + 2) + (error * coeff) / TotalCoeffSum;
1650	level = (BYTE)min(255, max(0, (int)nlevel));
1651	SetPixelIndex(x + i, y + 2, level);
1652	}
1653	}
1654	}
1655	break;
1656	}
1657	case 4:
1658	{
1659	//Jarvis, Judice and Ninke error diffusion (Thanks to Franco Gerevini)
1660	int TotalCoeffSum = 48;
1661	long error, nlevel, coeff=1;
1662	BYTE level;
1663
1664	for (long y = 0; y < head.biHeight; y++) {
1665	info.nProgress = (long)(100 * y / head.biHeight);
1666	if (info.nEscape)
1667	break;
1668	for (long x = 0; x < head.biWidth; x++) {
1669	level = BlindGetPixelIndex(x, y);
1670	if (level > 128) {
1671	tmp.SetPixelIndex(x, y, 1);
1672	error = level - 255;
1673	} else {
1674	tmp.SetPixelIndex(x, y, 0);
1675	error = level;
1676	}
1677
1678	nlevel = GetPixelIndex(x + 1, y) + (error * 7) / TotalCoeffSum;
1679	level = (BYTE)min(255, max(0, (int)nlevel));
1680	SetPixelIndex(x + 1, y, level);
1681	nlevel = GetPixelIndex(x + 2, y) + (error * 5) / TotalCoeffSum;
1682	level = (BYTE)min(255, max(0, (int)nlevel));
1683	SetPixelIndex(x + 2, y, level);
1684	int i;
1685	for (i = -2; i < 3; i++) {
1686	switch (i) {
1687	case -2:
1688	coeff = 3;
1689	break;
1690	case -1:
1691	coeff = 5;
1692	break;
1693	case 0:
1694	coeff = 7;
1695	break;
1696	case 1:
1697	coeff = 5;
1698	break;
1699	case 2:
1700	coeff = 3;
1701	break;
1702	}
1703	nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
1704	level = (BYTE)min(255, max(0, (int)nlevel));
1705	SetPixelIndex(x + i, y + 1, level);
1706	}
1707	for (i = -2; i < 3; i++) {
1708	switch (i) {
1709	case -2:
1710	coeff = 1;
1711	break;
1712	case -1:
1713	coeff = 3;
1714	break;
1715	case 0:
1716	coeff = 5;
1717	break;
1718	case 1:
1719	coeff = 3;
1720	break;
1721	case 2:
1722	coeff = 1;
1723	break;
1724	}
1725	nlevel = GetPixelIndex(x + i, y + 2) + (error * coeff) / TotalCoeffSum;
1726	level = (BYTE)min(255, max(0, (int)nlevel));
1727	SetPixelIndex(x + i, y + 2, level);
1728	}
1729	}
1730	}
1731	break;
1732	}
1733	case 5:
1734	{
1735	//Sierra error diffusion (Thanks to Franco Gerevini)
1736	int TotalCoeffSum = 32;
1737	long error, nlevel, coeff=1;
1738	BYTE level;
1739
1740	for (long y = 0; y < head.biHeight; y++) {
1741	info.nProgress = (long)(100 * y / head.biHeight);
1742	if (info.nEscape)
1743	break;
1744	for (long x = 0; x < head.biWidth; x++) {
1745	level = BlindGetPixelIndex(x, y);
1746	if (level > 128) {
1747	tmp.SetPixelIndex(x, y, 1);
1748	error = level - 255;
1749	} else {
1750	tmp.SetPixelIndex(x, y, 0);
1751	error = level;
1752	}
1753
1754	nlevel = GetPixelIndex(x + 1, y) + (error * 5) / TotalCoeffSum;
1755	level = (BYTE)min(255, max(0, (int)nlevel));
1756	SetPixelIndex(x + 1, y, level);
1757	nlevel = GetPixelIndex(x + 2, y) + (error * 3) / TotalCoeffSum;
1758	level = (BYTE)min(255, max(0, (int)nlevel));
1759	SetPixelIndex(x + 2, y, level);
1760	int i;
1761	for (i = -2; i < 3; i++) {
1762	switch (i) {
1763	case -2:
1764	coeff = 2;
1765	break;
1766	case -1:
1767	coeff = 4;
1768	break;
1769	case 0:
1770	coeff = 5;
1771	break;
1772	case 1:
1773	coeff = 4;
1774	break;
1775	case 2:
1776	coeff = 2;
1777	break;
1778	}
1779	nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
1780	level = (BYTE)min(255, max(0, (int)nlevel));
1781	SetPixelIndex(x + i, y + 1, level);
1782	}
1783	for (i = -1; i < 2; i++) {
1784	switch (i) {
1785	case -1:
1786	coeff = 2;
1787	break;
1788	case 0:
1789	coeff = 3;
1790	break;
1791	case 1:
1792	coeff = 2;
1793	break;
1794	}
1795	nlevel = GetPixelIndex(x + i, y + 2) + (error * coeff) / TotalCoeffSum;
1796	level = (BYTE)min(255, max(0, (int)nlevel));
1797	SetPixelIndex(x + i, y + 2, level);
1798	}
1799	}
1800	}
1801	break;
1802	}
1803	case 6:
1804	{
1805	//Stevenson and Arce error diffusion (Thanks to Franco Gerevini)
1806	int TotalCoeffSum = 200;
1807	long error, nlevel;
1808	BYTE level;
1809
1810	for (long y = 0; y < head.biHeight; y++) {
1811	info.nProgress = (long)(100 * y / head.biHeight);
1812	if (info.nEscape)
1813	break;
1814	for (long x = 0; x < head.biWidth; x++) {
1815	level = BlindGetPixelIndex(x, y);
1816	if (level > 128) {
1817	tmp.SetPixelIndex(x, y, 1);
1818	error = level - 255;
1819	} else {
1820	tmp.SetPixelIndex(x, y, 0);
1821	error = level;
1822	}
1823
1824	int tmp_index_x = x + 2;
1825	int tmp_index_y = y;
1826	int tmp_coeff = 32;
1827	nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
1828	level = (BYTE)min(255, max(0, (int)nlevel));
1829	SetPixelIndex(tmp_index_x, tmp_index_y, level);
1830
1831	tmp_index_x = x - 3;
1832	tmp_index_y = y + 1;
1833	tmp_coeff = 12;
1834	nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
1835	level = (BYTE)min(255, max(0, (int)nlevel));
1836	SetPixelIndex(tmp_index_x, tmp_index_y, level);
1837
1838	tmp_index_x = x - 1;
1839	tmp_coeff = 26;
1840	nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
1841	level = (BYTE)min(255, max(0, (int)nlevel));
1842	SetPixelIndex(tmp_index_x, tmp_index_y, level);
1843
1844	tmp_index_x = x + 1;
1845	tmp_coeff = 30;
1846	nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
1847	level = (BYTE)min(255, max(0, (int)nlevel));
1848	SetPixelIndex(tmp_index_x, tmp_index_y, level);
1849
1850	tmp_index_x = x + 3;
1851	tmp_coeff = 16;
1852	nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
1853	level = (BYTE)min(255, max(0, (int)nlevel));
1854	SetPixelIndex(tmp_index_x, tmp_index_y, level);
1855
1856	tmp_index_x = x - 2;
1857	tmp_index_y = y + 2;
1858	tmp_coeff = 12;
1859	nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
1860	level = (BYTE)min(255, max(0, (int)nlevel));
1861	SetPixelIndex(tmp_index_x, tmp_index_y, level);
1862
1863	tmp_index_x = x;
1864	tmp_coeff = 26;
1865	nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
1866	level = (BYTE)min(255, max(0, (int)nlevel));
1867	SetPixelIndex(tmp_index_x, tmp_index_y, level);
1868
1869	tmp_index_x = x + 2;
1870	tmp_coeff = 12;
1871	nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
1872	level = (BYTE)min(255, max(0, (int)nlevel));
1873	SetPixelIndex(tmp_index_x, tmp_index_y, level);
1874
1875	tmp_index_x = x - 3;
1876	tmp_index_y = y + 3;
1877	tmp_coeff = 5;
1878	nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
1879	level = (BYTE)min(255, max(0, (int)nlevel));
1880	SetPixelIndex(tmp_index_x, tmp_index_y, level);
1881
1882	tmp_index_x = x - 1;
1883	tmp_coeff = 12;
1884	nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
1885	level = (BYTE)min(255, max(0, (int)nlevel));
1886	SetPixelIndex(tmp_index_x, tmp_index_y, level);
1887
1888	tmp_index_x = x + 1;
1889	tmp_coeff = 12;
1890	nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
1891	level = (BYTE)min(255, max(0, (int)nlevel));
1892	SetPixelIndex(tmp_index_x, tmp_index_y, level);
1893
1894	tmp_index_x = x + 3;
1895	tmp_coeff = 5;
1896	nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
1897	level = (BYTE)min(255, max(0, (int)nlevel));
1898	SetPixelIndex(tmp_index_x, tmp_index_y, level);
1899	}
1900	}
1901	break;
1902	}
1903	case 7:
1904	{
1905	// Bayer ordered dither
1906	int order = 4;
1907	//create Bayer matrix
1908	if (order>4) order = 4;
1909	int size = (1 << (2*order));
1910	BYTE* Bmatrix = (BYTE) malloc(size sizeof(BYTE));
1911	for(int i = 0; i < size; i++) {
1912	int n = order;
1913	int x = i / n;
1914	int y = i % n;
1915	int dither = 0;
1916	while (n-- > 0){
1917	dither = (((dither<<1)\|((x&1) ^ (y&1)))<<1) \| (y&1);
1918	x >>= 1;
1919	y >>= 1;
1920	}
1921	Bmatrix[i] = (BYTE)(dither);
1922	}
1923
1924	int scale = max(0,(8-2*order));
1925	int level;
1926	for (long y=0;y<head.biHeight;y++){
1927	info.nProgress = (long)(100*y/head.biHeight);
1928	if (info.nEscape) break;
1929	for (long x=0;x<head.biWidth;x++){
1930	level = BlindGetPixelIndex(x,y) >> scale;
1931	if(level > Bmatrix[ (x % order) + order * (y % order) ]){
1932	tmp.SetPixelIndex(x,y,1);
1933	} else {
1934	tmp.SetPixelIndex(x,y,0);
1935	}
1936	}
1937	}
1938
1939	free(Bmatrix);
1940
1941	break;
1942	}
1943	default:
1944	{
1945	// Floyd-Steinberg error diffusion (Thanks to Steve McMahon)
1946	long error,nlevel,coeff=1;
1947	BYTE level;
1948
1949	for (long y=0;y<head.biHeight;y++){
1950	info.nProgress = (long)(100*y/head.biHeight);
1951	if (info.nEscape) break;
1952	for (long x=0;x<head.biWidth;x++){
1953
1954	level = BlindGetPixelIndex(x,y);
1955	if (level > 128){
1956	tmp.SetPixelIndex(x,y,1);
1957	error = level-255;
1958	} else {
1959	tmp.SetPixelIndex(x,y,0);
1960	error = level;
1961	}
1962
1963	nlevel = GetPixelIndex(x+1,y) + (error * 7)/16;
1964	level = (BYTE)min(255,max(0,(int)nlevel));
1965	SetPixelIndex(x+1,y,level);
1966	for(int i=-1; i<2; i++){
1967	switch(i){
1968	case -1:
1969	coeff=3; break;
1970	case 0:
1971	coeff=5; break;
1972	case 1:
1973	coeff=1; break;
1974	}
1975	nlevel = GetPixelIndex(x+i,y+1) + (error * coeff)/16;
1976	level = (BYTE)min(255,max(0,(int)nlevel));
1977	SetPixelIndex(x+i,y+1,level);
1978	}
1979	}
1980	}
1981	}
1982	}
1983
1984	tmp.SetPaletteColor(0,0,0,0);
1985	tmp.SetPaletteColor(1,255,255,255);
1986	Transfer(tmp);
1987
1988	return true;
1989	}
1990	////////////////////////////////////////////////////////////////////////////////
1991	/**
1992	* CropRotatedRectangle
1993	* \param topx,topy : topmost and leftmost point of the rectangle
1994	(topmost, and if there are 2 topmost points, the left one)
1995	* \param width : size of the right hand side of rect, from (topx,topy) roundwalking clockwise
1996	* \param height : size of the left hand side of rect, from (topx,topy) roundwalking clockwise
1997	* \param angle : angle of the right hand side of rect, from (topx,topy)
1998	* \param iDst : pointer to destination image (if 0, this image is modified)
1999	* \author [VATI]
2000	*/
2001	bool CxImage::CropRotatedRectangle( long topx, long topy, long width, long height, float angle, CxImage* iDst)
2002	{
2003	if (!pDib) return false;
2004
2005
2006	long startx,starty,endx,endy;
2007	double cos_angle = cos(angle//57.295779513082320877/);
2008	double sin_angle = sin(angle//57.295779513082320877/);
2009
2010	// if there is nothing special, call the original Crop():
2011	if ( fabs(angle)<0.0002 )
2012	return Crop( topx, topy, topx+width, topy+height, iDst);
2013
2014	startx = min(topx, topx - (long)(sin_angle*(double)height));
2015	endx = topx + (long)(cos_angle*(double)width);
2016	endy = topy + (long)(cos_angle(double)height + sin_angle(double)width);
2017	// check: corners of the rectangle must be inside
2018	if ( IsInside( startx, topy )==false \|\|
2019	IsInside( endx, endy ) == false )
2020	return false;
2021
2022	// first crop to bounding rectangle
2023	CxImage tmp(*this, true, false, true);
2024	// tmp.Copy(*this, true, false, true);
2025	if (!tmp.IsValid()){
2026	strcpy(info.szLastError,tmp.GetLastError());
2027	return false;
2028	}
2029	if (!tmp.Crop( startx, topy, endx, endy)){
2030	strcpy(info.szLastError,tmp.GetLastError());
2031	return false;
2032	}
2033
2034	// the midpoint of the image now became the same as the midpoint of the rectangle
2035	// rotate new image with minus angle amount
2036	if ( false == tmp.Rotate( (float)(-angle*57.295779513082320877) ) ) // Rotate expects angle in degrees
2037	return false;
2038
2039	// crop rotated image to the original selection rectangle
2040	endx = (tmp.head.biWidth+width)/2;
2041	startx = (tmp.head.biWidth-width)/2;
2042	starty = (tmp.head.biHeight+height)/2;
2043	endy = (tmp.head.biHeight-height)/2;
2044	if ( false == tmp.Crop( startx, starty, endx, endy ) )
2045	return false;
2046
2047	if (iDst) iDst->Transfer(tmp);
2048	else Transfer(tmp);
2049
2050	return true;
2051	}
2052	////////////////////////////////////////////////////////////////////////////////
2053	bool CxImage::Crop(const RECT& rect, CxImage* iDst)
2054	{
2055	return Crop(rect.left, rect.top, rect.right, rect.bottom, iDst);
2056	}
2057	////////////////////////////////////////////////////////////////////////////////
2058	bool CxImage::Crop(long left, long top, long right, long bottom, CxImage* iDst)
2059	{
2060	if (!pDib) return false;
2061
2062	long startx = max(0L,min(left,head.biWidth));
2063	long endx = max(0L,min(right,head.biWidth));
2064	long starty = head.biHeight - max(0L,min(top,head.biHeight));
2065	long endy = head.biHeight - max(0L,min(bottom,head.biHeight));
2066
2067	if (startx==endx \|\| starty==endy) return false;
2068
2069	if (startx>endx) {long tmp=startx; startx=endx; endx=tmp;}
2070	if (starty>endy) {long tmp=starty; starty=endy; endy=tmp;}
2071
2072	CxImage tmp(endx-startx,endy-starty,head.biBitCount,info.dwType);
2073	if (!tmp.IsValid()){
2074	strcpy(info.szLastError,tmp.GetLastError());
2075	return false;
2076	}
2077
2078	tmp.SetPalette(GetPalette(),head.biClrUsed);
2079	tmp.info.nBkgndIndex = info.nBkgndIndex;
2080	tmp.info.nBkgndColor = info.nBkgndColor;
2081
2082	switch (head.biBitCount) {
2083	case 1:
2084	case 4:
2085	{
2086	for(long y=starty, yd=0; y<endy; y++, yd++){
2087	info.nProgress = (long)(100*(y-starty)/(endy-starty)); //<Anatoly Ivasyuk>
2088	for(long x=startx, xd=0; x<endx; x++, xd++){
2089	tmp.SetPixelIndex(xd,yd,GetPixelIndex(x,y));
2090	}
2091	}
2092	break;
2093	}
2094	case 8:
2095	case 24:
2096	{
2097	int linelen = tmp.head.biWidth * tmp.head.biBitCount >> 3;
2098	BYTE* pDest = tmp.info.pImage;
2099	BYTE* pSrc = info.pImage + starty * info.dwEffWidth + (startx*head.biBitCount >> 3);
2100	for(long y=starty; y<endy; y++){
2101	info.nProgress = (long)(100*(y-starty)/(endy-starty)); //<Anatoly Ivasyuk>
2102	memcpy(pDest,pSrc,linelen);
2103	pDest+=tmp.info.dwEffWidth;
2104	pSrc+=info.dwEffWidth;
2105	}
2106	}
2107	}
2108
2109	#if CXIMAGE_SUPPORT_ALPHA
2110	if (AlphaIsValid()){ //<oboolo>
2111	tmp.AlphaCreate();
2112	if (!tmp.AlphaIsValid()) return false;
2113	BYTE* pDest = tmp.pAlpha;
2114	BYTE* pSrc = pAlpha + startx + starty*head.biWidth;
2115	for (long y=starty; y<endy; y++){
2116	memcpy(pDest,pSrc,endx-startx);
2117	pDest+=tmp.head.biWidth;
2118	pSrc+=head.biWidth;
2119	}
2120	}
2121	#endif //CXIMAGE_SUPPORT_ALPHA
2122
2123	//select the destination
2124	if (iDst) iDst->Transfer(tmp);
2125	else Transfer(tmp);
2126
2127	return true;
2128	}
2129	////////////////////////////////////////////////////////////////////////////////
2130	/**
2131	* \param xgain, ygain : can be from 0 to 1.
2132	* \param xpivot, ypivot : is the center of the transformation.
2133	* \param bEnableInterpolation : if true, enables bilinear interpolation.
2134	* \return true if everything is ok
2135	*/
2136	bool CxImage::Skew(float xgain, float ygain, long xpivot, long ypivot, bool bEnableInterpolation)
2137	{
2138	if (!pDib) return false;
2139	float nx,ny;
2140
2141	CxImage tmp(*this);
2142	if (!tmp.IsValid()){
2143	strcpy(info.szLastError,tmp.GetLastError());
2144	return false;
2145	}
2146
2147	long xmin,xmax,ymin,ymax;
2148	if (pSelection){
2149	xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
2150	ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
2151	} else {
2152	xmin = ymin = 0;
2153	xmax = head.biWidth; ymax=head.biHeight;
2154	}
2155	for(long y=ymin; y<ymax; y++){
2156	info.nProgress = (long)(100*(y-ymin)/(ymax-ymin));
2157	if (info.nEscape) break;
2158	for(long x=xmin; x<xmax; x++){
2159	#if CXIMAGE_SUPPORT_SELECTION
2160	if (BlindSelectionIsInside(x,y))
2161	#endif //CXIMAGE_SUPPORT_SELECTION
2162	{
2163	nx = x + (xgain*(y - ypivot));
2164	ny = y + (ygain*(x - xpivot));
2165	#if CXIMAGE_SUPPORT_INTERPOLATION
2166	if (bEnableInterpolation){
2167	tmp.SetPixelColor(x,y,GetPixelColorInterpolated(nx, ny, CxImage::IM_BILINEAR, CxImage::OM_BACKGROUND),true);
2168	} else
2169	#endif //CXIMAGE_SUPPORT_INTERPOLATION
2170	{
2171	if (head.biClrUsed==0){
2172	tmp.SetPixelColor(x,y,GetPixelColor((long)nx,(long)ny));
2173	} else {
2174	tmp.SetPixelIndex(x,y,GetPixelIndex((long)nx,(long)ny));
2175	}
2176	#if CXIMAGE_SUPPORT_ALPHA
2177	tmp.AlphaSet(x,y,AlphaGet((long)nx,(long)ny));
2178	#endif //CXIMAGE_SUPPORT_ALPHA
2179	}
2180	}
2181	}
2182	}
2183	Transfer(tmp);
2184	return true;
2185	}
2186	////////////////////////////////////////////////////////////////////////////////
2187	/**
2188	* Expands the borders.
2189	* \param left, top, right, bottom = additional dimensions, should be greater than 0.
2190	* \param canvascolor = border color. canvascolor.rgbReserved will set the alpha channel (if any) in the border.
2191	* \param iDst = pointer to destination image (if it's 0, this image is modified)
2192	* \return true if everything is ok
2193	* \author [Colin Urquhart]; changes [DP]
2194	*/
2195	bool CxImage::Expand(long left, long top, long right, long bottom, RGBQUAD canvascolor, CxImage* iDst)
2196	{
2197	if (!pDib) return false;
2198
2199	if ((left < 0) \|\| (right < 0) \|\| (bottom < 0) \|\| (top < 0)) return false;
2200
2201	long newWidth = head.biWidth + left + right;
2202	long newHeight = head.biHeight + top + bottom;
2203
2204	right = left + head.biWidth - 1;
2205	top = bottom + head.biHeight - 1;
2206
2207	CxImage tmp;
2208	tmp.CopyInfo(*this);
2209	if (!tmp.Create(newWidth, newHeight, head.biBitCount, info.dwType)){
2210	strcpy(info.szLastError,tmp.GetLastError());
2211	return false;
2212	}
2213
2214	tmp.SetPalette(GetPalette(),head.biClrUsed);
2215
2216	switch (head.biBitCount) {
2217	case 1:
2218	case 4:
2219	{
2220	BYTE pixel = tmp.GetNearestIndex(canvascolor);
2221	for(long y=0; y < newHeight; y++){
2222	info.nProgress = (long)(100*y/newHeight);
2223	for(long x=0; x < newWidth; x++){
2224	if ((y < bottom) \|\| (y > top) \|\| (x < left) \|\| (x > right)) {
2225	tmp.SetPixelIndex(x,y, pixel);
2226	} else {
2227	tmp.SetPixelIndex(x,y,GetPixelIndex(x-left,y-bottom));
2228	}
2229	}
2230	}
2231	break;
2232	}
2233	case 8:
2234	case 24:
2235	{
2236	if (head.biBitCount == 8) {
2237	BYTE pixel = tmp.GetNearestIndex( canvascolor);
2238	memset(tmp.info.pImage, pixel, + (tmp.info.dwEffWidth * newHeight));
2239	} else {
2240	for (long y = 0; y < newHeight; ++y) {
2241	BYTE pDest = tmp.info.pImage + (y tmp.info.dwEffWidth);
2242	for (long x = 0; x < newWidth; ++x) {
2243	*pDest++ = canvascolor.rgbBlue;
2244	*pDest++ = canvascolor.rgbGreen;
2245	*pDest++ = canvascolor.rgbRed;
2246	}
2247	}
2248	}
2249
2250	BYTE* pDest = tmp.info.pImage + (tmp.info.dwEffWidth * bottom) + (left*(head.biBitCount >> 3));
2251	BYTE* pSrc = info.pImage;
2252	for(long y=bottom; y <= top; y++){
2253	info.nProgress = (long)(100*y/(1 + top - bottom));
2254	memcpy(pDest,pSrc,(head.biBitCount >> 3) * (right - left + 1));
2255	pDest+=tmp.info.dwEffWidth;
2256	pSrc+=info.dwEffWidth;
2257	}
2258	}
2259	}
2260
2261	#if CXIMAGE_SUPPORT_SELECTION
2262	if (SelectionIsValid()){
2263	if (!tmp.SelectionCreate())
2264	return false;
2265	BYTE* pSrc = SelectionGetPointer();
2266	BYTE* pDst = tmp.SelectionGetPointer(left,bottom);
2267	for(long y=bottom; y <= top; y++){
2268	memcpy(pDst,pSrc, (right - left + 1));
2269	pSrc+=head.biWidth;
2270	pDst+=tmp.head.biWidth;
2271	}
2272	tmp.info.rSelectionBox.left = info.rSelectionBox.left + left;
2273	tmp.info.rSelectionBox.right = info.rSelectionBox.right + left;
2274	tmp.info.rSelectionBox.top = info.rSelectionBox.top + bottom;
2275	tmp.info.rSelectionBox.bottom = info.rSelectionBox.bottom + bottom;
2276	}
2277	#endif //CXIMAGE_SUPPORT_SELECTION
2278
2279	#if CXIMAGE_SUPPORT_ALPHA
2280	if (AlphaIsValid()){
2281	if (!tmp.AlphaCreate())
2282	return false;
2283	tmp.AlphaSet(canvascolor.rgbReserved);
2284	BYTE* pSrc = AlphaGetPointer();
2285	BYTE* pDst = tmp.AlphaGetPointer(left,bottom);
2286	for(long y=bottom; y <= top; y++){
2287	memcpy(pDst,pSrc, (right - left + 1));
2288	pSrc+=head.biWidth;
2289	pDst+=tmp.head.biWidth;
2290	}
2291	}
2292	#endif //CXIMAGE_SUPPORT_ALPHA
2293
2294	//select the destination
2295	if (iDst) iDst->Transfer(tmp);
2296	else Transfer(tmp);
2297
2298	return true;
2299	}
2300	////////////////////////////////////////////////////////////////////////////////
2301	bool CxImage::Expand(long newx, long newy, RGBQUAD canvascolor, CxImage* iDst)
2302	{
2303	//thanks to <Colin Urquhart>
2304
2305	if (!pDib) return false;
2306
2307	if ((newx < head.biWidth) \|\| (newy < head.biHeight)) return false;
2308
2309	int nAddLeft = (newx - head.biWidth) / 2;
2310	int nAddTop = (newy - head.biHeight) / 2;
2311
2312	return Expand(nAddLeft, nAddTop, newx - (head.biWidth + nAddLeft), newy - (head.biHeight + nAddTop), canvascolor, iDst);
2313	}
2314	////////////////////////////////////////////////////////////////////////////////
2315	/**
2316	* Resamples the image with the correct aspect ratio, and fills the borders.
2317	* \param newx, newy = thumbnail size.
2318	* \param canvascolor = border color.
2319	* \param iDst = pointer to destination image (if it's 0, this image is modified).
2320	* \return true if everything is ok.
2321	* \author [Colin Urquhart]
2322	*/
2323	bool CxImage::Thumbnail(long newx, long newy, RGBQUAD canvascolor, CxImage* iDst)
2324	{
2325	if (!pDib) return false;
2326
2327	if ((newx <= 0) \|\| (newy <= 0)) return false;
2328
2329	CxImage tmp(*this);
2330	if (!tmp.IsValid()){
2331	strcpy(info.szLastError,tmp.GetLastError());
2332	return false;
2333	}
2334
2335	// determine whether we need to shrink the image
2336	if ((head.biWidth > newx) \|\| (head.biHeight > newy)) {
2337	float fScale;
2338	float fAspect = (float) newx / (float) newy;
2339	if (fAspect * head.biHeight > head.biWidth) {
2340	fScale = (float) newy / head.biHeight;
2341	} else {
2342	fScale = (float) newx / head.biWidth;
2343	}
2344	tmp.Resample((long) (fScale * head.biWidth), (long) (fScale * head.biHeight), 0);
2345	}
2346
2347	// expand the frame
2348	tmp.Expand(newx, newy, canvascolor, iDst);
2349
2350	//select the destination
2351	if (iDst) iDst->Transfer(tmp);
2352	else Transfer(tmp);
2353	return true;
2354	}
2355	////////////////////////////////////////////////////////////////////////////////
2356	/**
2357	* Perform circle_based transformations.
2358	* \param type - for different transformations
2359	* - 0 for normal (proturberant) FishEye
2360	* - 1 for reverse (concave) FishEye
2361	* - 2 for Swirle
2362	* - 3 for Cilinder mirror
2363	* - 4 for bathroom
2364	*
2365	* \param rmax - effect radius. If 0, the whole image is processed
2366	* \param Koeff - only for swirle
2367	* \author Arkadiy Olovyannikov ark(at)msun(dot)ru
2368	*/
2369	bool CxImage::CircleTransform(int type,long rmax,float Koeff)
2370	{
2371	if (!pDib) return false;
2372
2373	long nx,ny;
2374	double angle,radius,rnew;
2375
2376	CxImage tmp(*this);
2377	if (!tmp.IsValid()){
2378	strcpy(info.szLastError,tmp.GetLastError());
2379	return false;
2380	}
2381
2382	long xmin,xmax,ymin,ymax,xmid,ymid;
2383	if (pSelection){
2384	xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;
2385	ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;
2386	} else {
2387	xmin = ymin = 0;
2388	xmax = head.biWidth; ymax=head.biHeight;
2389	}
2390
2391	xmid = (long) (tmp.GetWidth()/2);
2392	ymid = (long) (tmp.GetHeight()/2);
2393
2394	if (!rmax) rmax=(long)sqrt((float)((xmid-xmin)(xmid-xmin)+(ymid-ymin)(ymid-ymin)));
2395	if (Koeff==0.0f) Koeff=1.0f;
2396
2397	for(long y=ymin; y<ymax; y++){
2398	info.nProgress = (long)(100*(y-ymin)/(ymax-ymin));
2399	if (info.nEscape) break;
2400	for(long x=xmin; x<xmax; x++){
2401	#if CXIMAGE_SUPPORT_SELECTION
2402	if (BlindSelectionIsInside(x,y))
2403	#endif //CXIMAGE_SUPPORT_SELECTION
2404	{
2405	nx=xmid-x;
2406	ny=ymid-y;
2407	radius=sqrt((float)(nxnx+nyny));
2408	if (radius<rmax) {
2409	angle=atan2((double)ny,(double)nx);
2410	if (type==0) rnew=radius*radius/rmax;
2411	else if (type==1) rnew=sqrt(radius*rmax);
2412	else if (type==2) {rnew=radius;angle += radius / Koeff;}
2413	else rnew = 1; // potentially uninitialized
2414	if (type<3){
2415	nx = xmid + (long)(rnew * cos(angle));
2416	ny = ymid - (long)(rnew * sin(angle));
2417	}
2418	else if (type==3){
2419	nx = (long)fabs((angle*xmax/6.2831852));
2420	ny = (long)fabs((radius*ymax/rmax));
2421	}
2422	else {
2423	nx=x+(x%32)-16;
2424	ny=y;
2425	}
2426	// nx=max(xmin,min(nx,xmax));
2427	// ny=max(ymin,min(ny,ymax));
2428	}
2429	else { nx=-1;ny=-1;}
2430	if (head.biClrUsed==0){
2431	tmp.SetPixelColor(x,y,GetPixelColor(nx,ny));
2432	} else {
2433	tmp.SetPixelIndex(x,y,GetPixelIndex(nx,ny));
2434	}
2435	#if CXIMAGE_SUPPORT_ALPHA
2436	tmp.AlphaSet(x,y,AlphaGet(nx,ny));
2437	#endif //CXIMAGE_SUPPORT_ALPHA
2438	}
2439	}
2440	}
2441	Transfer(tmp);
2442	return true;
2443	}
2444	////////////////////////////////////////////////////////////////////////////////
2445	/**
2446	* Faster way to almost properly shrink image. Algorithm produces results comparable with "high resoultion shrink"
2447	* when resulting image is much smaller (that would be 3 times or more) than original. When
2448	* resulting image is only slightly smaller, results are closer to nearest pixel.
2449	* This algorithm works by averaging, but it does not calculate fractions of pixels. It adds whole
2450	* source pixels to the best destionation. It is not geometrically "correct".
2451	* It's main advantage over "high" resulution shrink is speed, so it's useful, when speed is most
2452	* important (preview thumbnails, "map" view, ...).
2453	* Method is optimized for RGB24 images.
2454	*
2455	* \param newx, newy - size of destination image (must be smaller than original!)
2456	* \param iDst - pointer to destination image (if it's 0, this image is modified)
2457	* \param bChangeBpp - flag points to change result image bpp (if it's true, this result image bpp = 24 (useful for B/W image thumbnails))
2458	*
2459	* \return true if everything is ok
2460	* \author [bd], 9.2004; changes [Artiom Mirolubov], 1.2005
2461	*/
2462	bool CxImage::QIShrink(long newx, long newy, CxImage* const iDst, bool bChangeBpp)
2463	{
2464	if (!pDib) return false;
2465
2466	if (newx>head.biWidth \|\| newy>head.biHeight) {
2467	//let me repeat... this method can't enlarge image
2468	strcpy(info.szLastError,"QIShrink can't enlarge image");
2469	return false;
2470	}
2471
2472	if (newx==head.biWidth && newy==head.biHeight) {
2473	//image already correct size (just copy and return)
2474	if (iDst) iDst->Copy(*this);
2475	return true;
2476	}//if
2477
2478	//create temporary destination image
2479	CxImage newImage;
2480	newImage.CopyInfo(*this);
2481	newImage.Create(newx,newy,(bChangeBpp)?24:head.biBitCount,GetType());
2482	newImage.SetPalette(GetPalette());
2483	if (!newImage.IsValid()){
2484	strcpy(info.szLastError,newImage.GetLastError());
2485	return false;
2486	}
2487
2488	//and alpha channel if required
2489	#if CXIMAGE_SUPPORT_ALPHA
2490	if (AlphaIsValid()) newImage.AlphaCreate();
2491	#endif
2492
2493	const int oldx = head.biWidth;
2494	const int oldy = head.biHeight;
2495
2496	int accuCellSize = 4;
2497	#if CXIMAGE_SUPPORT_ALPHA
2498	BYTE *alphaPtr;
2499	if (AlphaIsValid()) accuCellSize=5;
2500	#endif
2501
2502	unsigned int accu = new unsigned int[newxaccuCellSize]; //array for suming pixels... one pixel for every destination column
2503	unsigned int *accuPtr; //pointer for walking through accu
2504	//each cell consists of blue, red, green component and count of pixels summed in this cell
2505	memset(accu, 0, newx * accuCellSize * sizeof(unsigned int)); //clear accu
2506
2507	if (!IsIndexed()) {
2508	//RGB24 version with pointers
2509	BYTE destPtr, srcPtr, destPtrS, srcPtrS; //destination and source pixel, and beginnings of current row
2510	srcPtrS=(BYTE*)BlindGetPixelPointer(0,0);
2511	destPtrS=(BYTE*)newImage.BlindGetPixelPointer(0,0);
2512	int ex=0, ey=0; //ex and ey replace division...
2513	int dy=0;
2514	//(we just add pixels, until by adding newx or newy we get a number greater than old size... then
2515	// it's time to move to next pixel)
2516
2517	for(int y=0; y<oldy; y++){ //for all source rows
2518	info.nProgress = (long)(100*y/oldy); if (info.nEscape) break;
2519	ey += newy;
2520	ex = 0; //restart with ex = 0
2521	accuPtr=accu; //restart from beginning of accu
2522	srcPtr=srcPtrS; //and from new source line
2523	#if CXIMAGE_SUPPORT_ALPHA
2524	alphaPtr = AlphaGetPointer(0, y);
2525	#endif
2526
2527	for(int x=0; x<oldx; x++){ //for all source columns
2528	ex += newx;
2529	accuPtr += (srcPtr++); //add current pixel to current accu slot
2530	(accuPtr+1) += (srcPtr++);
2531	(accuPtr+2) += (srcPtr++);
2532	(*(accuPtr+3)) ++;
2533	#if CXIMAGE_SUPPORT_ALPHA
2534	if (alphaPtr) (accuPtr+4) += (alphaPtr++);
2535	#endif
2536	if (ex>oldx) { //when we reach oldx, it's time to move to new slot
2537	accuPtr += accuCellSize;
2538	ex -= oldx; //(substract oldx from ex and resume from there on)
2539	}//if (ex overflow)
2540	}//for x
2541
2542	if (ey>=oldy) { //now when this happens
2543	ey -= oldy; //it's time to move to new destination row
2544	destPtr = destPtrS; //reset pointers to proper initial values
2545	accuPtr = accu;
2546	#if CXIMAGE_SUPPORT_ALPHA
2547	alphaPtr = newImage.AlphaGetPointer(0, dy++);
2548	#endif
2549	for (int k=0; k<newx; k++) { //copy accu to destination row (divided by number of pixels in each slot)
2550	(destPtr++) = (BYTE)((accuPtr) / *(accuPtr+3));
2551	(destPtr++) = (BYTE)((accuPtr+1) / *(accuPtr+3));
2552	(destPtr++) = (BYTE)((accuPtr+2) / *(accuPtr+3));
2553	#if CXIMAGE_SUPPORT_ALPHA
2554	if (alphaPtr) (alphaPtr++) = (BYTE)((accuPtr+4) / *(accuPtr+3));
2555	#endif
2556	accuPtr += accuCellSize;
2557	}//for k
2558	memset(accu, 0, newx * accuCellSize * sizeof(unsigned int)); //clear accu
2559	destPtrS += newImage.info.dwEffWidth;
2560	}//if (ey overflow)
2561
2562	srcPtrS += info.dwEffWidth; //next round we start from new source row
2563	}//for y
2564	} else {
2565	//standard version with GetPixelColor...
2566	int ex=0, ey=0; //ex and ey replace division...
2567	int dy=0;
2568	//(we just add pixels, until by adding newx or newy we get a number greater than old size... then
2569	// it's time to move to next pixel)
2570	RGBQUAD rgb;
2571
2572	for(int y=0; y<oldy; y++){ //for all source rows
2573	info.nProgress = (long)(100*y/oldy); if (info.nEscape) break;
2574	ey += newy;
2575	ex = 0; //restart with ex = 0
2576	accuPtr=accu; //restart from beginning of accu
2577	for(int x=0; x<oldx; x++){ //for all source columns
2578	ex += newx;
2579	rgb = GetPixelColor(x, y, true);
2580	*accuPtr += rgb.rgbBlue; //add current pixel to current accu slot
2581	*(accuPtr+1) += rgb.rgbRed;
2582	*(accuPtr+2) += rgb.rgbGreen;
2583	(*(accuPtr+3)) ++;
2584	#if CXIMAGE_SUPPORT_ALPHA
2585	if (pAlpha) *(accuPtr+4) += rgb.rgbReserved;
2586	#endif
2587	if (ex>oldx) { //when we reach oldx, it's time to move to new slot
2588	accuPtr += accuCellSize;
2589	ex -= oldx; //(substract oldx from ex and resume from there on)
2590	}//if (ex overflow)
2591	}//for x
2592
2593	if (ey>=oldy) { //now when this happens
2594	ey -= oldy; //it's time to move to new destination row
2595	accuPtr = accu;
2596	for (int dx=0; dx<newx; dx++) { //copy accu to destination row (divided by number of pixels in each slot)
2597	rgb.rgbBlue = (BYTE)((accuPtr) / (accuPtr+3));
2598	rgb.rgbRed = (BYTE)((accuPtr+1) / (accuPtr+3));
2599	rgb.rgbGreen= (BYTE)((accuPtr+2) / (accuPtr+3));
2600	#if CXIMAGE_SUPPORT_ALPHA
2601	if (pAlpha) rgb.rgbReserved = (BYTE)((accuPtr+4) / (accuPtr+3));
2602	#endif
2603	newImage.SetPixelColor(dx, dy, rgb, pAlpha!=0);
2604	accuPtr += accuCellSize;
2605	}//for dx
2606	memset(accu, 0, newx * accuCellSize * sizeof(unsigned int)); //clear accu
2607	dy++;
2608	}//if (ey overflow)
2609	}//for y
2610	}//if
2611
2612	delete [] accu; //delete helper array
2613
2614	//copy new image to the destination
2615	if (iDst)
2616	iDst->Transfer(newImage);
2617	else
2618	Transfer(newImage);
2619	return true;
2620
2621	}
2622
2623	////////////////////////////////////////////////////////////////////////////////
2624	#endif //CXIMAGE_SUPPORT_TRANSFORMATION

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: liacs/MIR2010/SourceCode/cximage/ximatran.cpp@ 404

Download in other formats: