Attachment #454888 for bug #592446




		bihtoh(&infohdr);

		// Write the file header
		hFile->Write(&hdr,minimum(14,sizeof(BITMAPFILEHEADER)),1);
		hFile->Write(&infohdr,sizeof(BITMAPINFOHEADER),1);
		 //and DIB+ALPHA interlaced
		BYTE *srcalpha = AlphaGetPointer();

#endif //CXIMAGE_SUPPORT_ALPHA
	{
		// Write the file header
		hFile->Write(&hdr,minimum(14,sizeof(BITMAPFILEHEADER)),1);
		//copy attributes
		memcpy(pDib,&head,sizeof(BITMAPINFOHEADER));
		bihtoh((BITMAPINFOHEADER*)pDib);

	BITMAPFILEHEADER   bf;
	DWORD off = hFile->Tell(); //<CSC>
  cx_try {
	if (hFile->Read(&bf,minimum(14,sizeof(bf)),1)==0) cx_throw("Not a BMP");

	bf.bfSize = my_ntohl(bf.bfSize); 
	bf.bfOffBits = my_ntohl(bf.bfOffBits); 

Lines 53-63 Link Here

(-)a/lib/cximage-6.0/CxImage/ximadef.h (-4 / +4 lines)
53	#define CXIMAGE_SUPPORT_WINDOWS 0	53	#define CXIMAGE_SUPPORT_WINDOWS 0
54	#endif	54	#endif
55		55
56	#ifndef min	56	#ifndef minimum
57	#define min(a,b) (((a)<(b))?(a):(b))	57	#define minimum(a,b) (((a)<(b))?(a):(b))
58	#endif	58	#endif
59	#ifndef max	59	#ifndef maximum
60	#define max(a,b) (((a)>(b))?(a):(b))	60	#define maximum(a,b) (((a)>(b))?(a):(b))
61	#endif	61	#endif
62		62
63	#ifndef PI	63	#ifndef PI




	G = lRGBColor.rgbGreen;
	B = lRGBColor.rgbBlue;

	cMax = maximum( maximum(R,G), B);	/* calculate lightness */
	cMin = minimum( minimum(R,G), B);
	L = (BYTE)((((cMax+cMin)*HSLMAX)+RGBMAX)/(2*RGBMAX));

	if (cMax==cMin){			/* r=g=b --> achromatic case */

	G = (int)( Y - 0.344f * U - 0.714f * V);
	B = (int)( Y + 1.770f * U);

	R= minimum(255,maximum(0,R));
	G= minimum(255,maximum(0,G));
	B= minimum(255,maximum(0,B));
	RGBQUAD rgb={(BYTE)B,(BYTE)G,(BYTE)R,0};
	return rgb;
}

	U = (int)((B-Y) * 0.565f + 128);
	V = (int)((R-Y) * 0.713f + 128);

	Y= minimum(255,maximum(0,Y));
	U= minimum(255,maximum(0,U));
	V= minimum(255,maximum(0,V));
	RGBQUAD yuv={(BYTE)V,(BYTE)U,(BYTE)Y,0};
	return yuv;
}

	G = (int)( Y - 0.273f * I - 0.647f * Q);
	B = (int)( Y - 1.104f * I + 1.701f * Q);

	R= minimum(255,maximum(0,R));
	G= minimum(255,maximum(0,G));
	B= minimum(255,maximum(0,B));
	RGBQUAD rgb={(BYTE)B,(BYTE)G,(BYTE)R,0};
	return rgb;
}

	I = (int)( 0.5960f * R - 0.2742f * G - 0.3219f * B + 128);
	Q = (int)( 0.2109f * R - 0.5229f * G + 0.3120f * B + 128);

	Y= minimum(255,maximum(0,Y));
	I= minimum(255,maximum(0,I));
	Q= minimum(255,maximum(0,Q));
	RGBQUAD yiq={(BYTE)Q,(BYTE)I,(BYTE)Y,0};
	return yiq;
}

	G = (int)( -0.969256f * X + 1.875992f * Y + 0.041556f * Z * k);
	B = (int)(  0.055648f * X - 0.204043f * Y + 1.057311f * Z * k);

	R= minimum(255,maximum(0,R));
	G= minimum(255,maximum(0,G));
	B= minimum(255,maximum(0,B));
	RGBQUAD rgb={(BYTE)B,(BYTE)G,(BYTE)R,0};
	return rgb;
}

	Y = (int)( 0.212671f * R + 0.715160f * G + 0.072169f * B);
	Z = (int)((0.019334f * R + 0.119193f * G + 0.950227f * B)*0.918483657f);

	//X= minimum(255,maximum(0,X));
	//Y= minimum(255,maximum(0,Y));
	//Z= minimum(255,maximum(0,Z));
	RGBQUAD xyz={(BYTE)Z,(BYTE)Y,(BYTE)X,0};
	return xyz;
}


	BYTE cTable[256]; //<nipper>
	for (int i=0;i<256;i++)	{
		cTable[i] = (BYTE)maximum(0,minimum(255,(int)((i-128)*c + brightness + 0.5f)));
	}

	return Lut(cTable);

						}
					}
					if (Kfactor==0 || ksumcur==0){
						cPtr2[iY1] = (BYTE)minimum(255, maximum(0,(int)(b + Koffset)));
					} else if (ksumtot == ksumcur) {
						cPtr2[iY1] = (BYTE)minimum(255, maximum(0,(int)(b/Kfactor + Koffset)));
					} else {
						cPtr2[iY1] = (BYTE)minimum(255, maximum(0,(int)((b*ksumtot)/(ksumcur*Kfactor) + Koffset)));
					}
				}
			}

						}
					}
					if (Kfactor==0 || ksumcur==0){
						c.rgbRed   = (BYTE)minimum(255, maximum(0,(int)(r + Koffset)));
						c.rgbGreen = (BYTE)minimum(255, maximum(0,(int)(g + Koffset)));
						c.rgbBlue  = (BYTE)minimum(255, maximum(0,(int)(b + Koffset)));
					} else if (ksumtot == ksumcur) {
						c.rgbRed   = (BYTE)minimum(255, maximum(0,(int)(r/Kfactor + Koffset)));
						c.rgbGreen = (BYTE)minimum(255, maximum(0,(int)(g/Kfactor + Koffset)));
						c.rgbBlue  = (BYTE)minimum(255, maximum(0,(int)(b/Kfactor + Koffset)));
					} else {
						c.rgbRed   = (BYTE)minimum(255, maximum(0,(int)((r*ksumtot)/(ksumcur*Kfactor) + Koffset)));
						c.rgbGreen = (BYTE)minimum(255, maximum(0,(int)((g*ksumtot)/(ksumcur*Kfactor) + Koffset)));
						c.rgbBlue  = (BYTE)minimum(255, maximum(0,(int)((b*ksumtot)/(ksumcur*Kfactor) + Koffset)));
					}
					tmp.BlindSetPixelColor(x,y,c);
				}

// 
void CxImage::Mix(CxImage & imgsrc2, ImageOpType op, long lXOffset, long lYOffset, bool bMixAlpha)
{
    long lWide = minimum(GetWidth(),imgsrc2.GetWidth()-lXOffset);
    long lHeight = minimum(GetHeight(),imgsrc2.GetHeight()-lYOffset);

	bool bEditAlpha = imgsrc2.AlphaIsValid() & bMixAlpha;


						if (bEditAlpha) rgbDest.rgbReserved = (BYTE)((rgb1.rgbReserved+rgb2.rgbReserved)/2);
					break;
					case OpAdd:
						rgbDest.rgbBlue = (BYTE)maximum(0,minimum(255,rgb1.rgbBlue+rgb2.rgbBlue));
						rgbDest.rgbGreen = (BYTE)maximum(0,minimum(255,rgb1.rgbGreen+rgb2.rgbGreen));
						rgbDest.rgbRed = (BYTE)maximum(0,minimum(255,rgb1.rgbRed+rgb2.rgbRed));
						if (bEditAlpha) rgbDest.rgbReserved = (BYTE)maximum(0,minimum(255,rgb1.rgbReserved+rgb2.rgbReserved));
					break;
					case OpSub:
						rgbDest.rgbBlue = (BYTE)maximum(0,minimum(255,rgb1.rgbBlue-rgb2.rgbBlue));
						rgbDest.rgbGreen = (BYTE)maximum(0,minimum(255,rgb1.rgbGreen-rgb2.rgbGreen));
						rgbDest.rgbRed = (BYTE)maximum(0,minimum(255,rgb1.rgbRed-rgb2.rgbRed));
						if (bEditAlpha) rgbDest.rgbReserved = (BYTE)maximum(0,minimum(255,rgb1.rgbReserved-rgb2.rgbReserved));
					break;
					case OpAnd:
						rgbDest.rgbBlue = (BYTE)(rgb1.rgbBlue&rgb2.rgbBlue);

							double dSmallAmt = dSmall*((double)rgb2.rgbBlue);

							if( lAverage < lThresh+1){
								rgbDest.rgbBlue = (BYTE)maximum(0,minimum(255,(int)(dLarge*((double)rgb1.rgbBlue) +
												dSmallAmt)));
								rgbDest.rgbGreen = (BYTE)maximum(0,minimum(255,(int)(dLarge*((double)rgb1.rgbGreen) +
												dSmallAmt)));
								rgbDest.rgbRed = (BYTE)maximum(0,minimum(255,(int)(dLarge*((double)rgb1.rgbRed) +
												dSmallAmt)));
							}
							else

#endif //CXIMAGE_SUPPORT_SELECTION
				{
					color = BlindGetPixelColor(x,y);
					color.rgbRed = (BYTE)maximum(0,minimum(255,(int)(color.rgbRed + r)));
					color.rgbGreen = (BYTE)maximum(0,minimum(255,(int)(color.rgbGreen + g)));
					color.rgbBlue = (BYTE)maximum(0,minimum(255,(int)(color.rgbBlue + b)));
					BlindSetPixelColor(x,y,color);
				}
			}

	} else {
		for(DWORD j=0; j<head.biClrUsed; j++){
			color = GetPaletteColor((BYTE)j);
			color.rgbRed = (BYTE)maximum(0,minimum(255,(int)(color.rgbRed + r)));
			color.rgbGreen = (BYTE)maximum(0,minimum(255,(int)(color.rgbGreen + g)));
			color.rgbBlue = (BYTE)maximum(0,minimum(255,(int)(color.rgbBlue + b)));
			SetPaletteColor((BYTE)j,color);
		}
	}


	BYTE cTable[256]; //<nipper>
	for (int i=0;i<256;i++)	{
		cTable[i] = (BYTE)maximum(0,minimum(255,(int)( pow((double)i, dinvgamma) / dMax)));
	}

	return Lut(cTable);

	dMax = pow(255.0, dinvgamma) / 255.0;
	BYTE cTableR[256];
	for (i=0;i<256;i++)	{
		cTableR[i] = (BYTE)maximum(0,minimum(255,(int)( pow((double)i, dinvgamma) / dMax)));
	}

	dinvgamma = 1/gammaG;
	dMax = pow(255.0, dinvgamma) / 255.0;
	BYTE cTableG[256];
	for (i=0;i<256;i++)	{
		cTableG[i] = (BYTE)maximum(0,minimum(255,(int)( pow((double)i, dinvgamma) / dMax)));
	}

	dinvgamma = 1/gammaB;
	dMax = pow(255.0, dinvgamma) / 255.0;
	BYTE cTableB[256];
	for (i=0;i<256;i++)	{
		cTableB[i] = (BYTE)maximum(0,minimum(255,(int)( pow((double)i, dinvgamma) / dMax)));
	}

	return Lut(cTableR, cTableG, cTableB);

			{
				color = BlindGetPixelColor(x,y);
				n=(long)((rand()/(float)RAND_MAX - 0.5)*level);
				color.rgbRed = (BYTE)maximum(0,minimum(255,(int)(color.rgbRed + n)));
				n=(long)((rand()/(float)RAND_MAX - 0.5)*level);
				color.rgbGreen = (BYTE)maximum(0,minimum(255,(int)(color.rgbGreen + n)));
				n=(long)((rand()/(float)RAND_MAX - 0.5)*level);
				color.rgbBlue = (BYTE)maximum(0,minimum(255,(int)(color.rgbBlue + n)));
				BlindSetPixelColor(x,y,color);
			}
		}


	//DFT buffers
	double *real2,*imag2;
	real2 = (double*)malloc(maximum(w,h) * sizeof(double));
	imag2 = (double*)malloc(maximum(w,h) * sizeof(double));

	/* Transform the rows */
	real = (double *)malloc(w * sizeof(double));


	/* converting from double to byte, there is a HUGE loss in the dynamics
	  "nn" tries to keep an acceptable SNR, but 8bit=48dB: don't ask more */
	double nn=pow((double)2,(double)log((double)maximum(w,h))/(double)log((double)2)-4);
	//reversed gain for reversed transform
	if (direction==-1) nn=1/nn;
	//bMagnitude : just to see it on the screen

	for (j=0;j<h;j++) {
		for (k=0;k<w;k++) {
			if (bMagnitude){
				tmpReal->SetPixelIndex(k,j,(BYTE)maximum(0,minimum(255,(nn*(3+log(_cabs(grid[k][j])))))));
				if (grid[k][j].x==0){
					tmpImag->SetPixelIndex(k,j,(BYTE)maximum(0,minimum(255,(128+(atan(grid[k][j].y/0.0000000001)*nn)))));
				} else {
					tmpImag->SetPixelIndex(k,j,(BYTE)maximum(0,minimum(255,(128+(atan(grid[k][j].y/grid[k][j].x)*nn)))));
				}
			} else {
				tmpReal->SetPixelIndex(k,j,(BYTE)maximum(0,minimum(255,(128 + grid[k][j].x*nn))));
				tmpImag->SetPixelIndex(k,j,(BYTE)maximum(0,minimum(255,(128 + grid[k][j].y*nn))));
			}
		}
	}


			correction = ((1.0+iy*iy)*ixx - ix*iy*ixy + (1.0+ix*ix)*iyy)/(1.0+ix*ix+iy*iy);

			tmp.BlindSetPixelIndex(x,y,(BYTE)minimum(255,maximum(0,(xy0 + radius * correction + 0.5))));
		}
	}



			correction = ((1.0+iy*iy)*ixx - ix*iy*ixy + (1.0+ix*ix)*iyy)/(1.0+ix*ix+iy*iy);

			tmp.BlindSetPixelIndex(x,y,(BYTE)minimum(255,maximum(0,(xy0 + radius * correction + 0.5))));
		}
	}
	for (x=0;x<=w;x+=w){


			correction = ((1.0+iy*iy)*ixx - ix*iy*ixy + (1.0+ix*ix)*iyy)/(1.0+ix*ix+iy*iy);

			tmp.BlindSetPixelIndex(x,y,(BYTE)minimum(255,maximum(0,(xy0 + radius * correction + 0.5))));
		}
	}


	}

	//build the difference mask
	BYTE thresh_dw = (BYTE)maximum( 0 ,(int)(128 - threshold));
	BYTE thresh_up = (BYTE)minimum(255,(int)(128 + threshold));
	long kernel[]={-100,-100,-100,-100,801,-100,-100,-100,-100};
	if (!Tmp.Filter(kernel,3,800,128)){
		delete [] pPalette;

					if (abs(diff) < threshold){
						dest_row[z] = cur_row[z];
					} else {
						dest_row[z] = (BYTE)minimum(255, maximum(0,(int)(cur_row[z] + amount * diff)));
					}
				}
			}

				float a = 1.0f-5.0f*((float)((x-0.5f*(xmax+xmin))*(x-0.5f*(xmax+xmin))+(y-0.5f*(ymax+ymin))*(y-0.5f*(ymax+ymin))))/((float)((xmax-xmin)*(ymax-ymin)));
				if (a<0) a=0;
				color = BlindGetPixelColor(x,y);
				color.rgbRed = (BYTE)(a*minimum(color.rgbGreen,color.rgbBlue)+(1.0f-a)*color.rgbRed);
				BlindSetPixelColor(x,y,color);
			}
		}

	case 1:
		{
			for (int i=0;i<256;i++)	{
				cTable[i] = (BYTE)maximum(0,minimum(255,(int)(i + saturation)));
			}
			for(long y=ymin; y<ymax; y++){
				info.nProgress = (long)(100*(y-ymin)/(ymax-ymin));

	case 2:
		{
			for (int i=0;i<256;i++)	{
				cTable[i] = (BYTE)maximum(0,minimum(255,(int)((i-128)*(100 + saturation)/100.0f + 128.5f)));
			}
			for(long y=ymin; y<ymax; y++){
				info.nProgress = (long)(100*(y-ymin)/(ymax-ymin));


	long xmin,xmax,ymin,ymax;
	if (pBox){
		xmin = maximum(pBox->left,0);
		xmax = minimum(pBox->right,head.biWidth);
		ymin = maximum(pBox->bottom,0);
		ymax = minimum(pBox->top,head.biHeight);
	} else {
		xmin = ymin = 0;
		xmax = head.biWidth; ymax=head.biHeight;

			r.top = r.bottom + nBoxSize;
			int threshold = OptimalThreshold(method, &r, pContrastMask);
			if (threshold <0) return false;
			mask.SetPixelIndex(x,y,(BYTE)maximum(0,minimum(255,nBias+((1.0f-fGlobalLocalBalance)*threshold + fGlobalLocalBalance*globalthreshold))));
		}
	}


	if (IsIndexed()){ //--- Generic indexed image, no tolerance OR Grayscale image with tolerance
		BYTE idxRef = GetPixelIndex(xStart,yStart);
		BYTE idxFill = GetNearestIndex(cFillColor);
		BYTE idxMin = (BYTE)minimum(255, maximum(0,(int)(idxRef - nTolerance)));
		BYTE idxMax = (BYTE)minimum(255, maximum(0,(int)(idxRef + nTolerance)));

		while(!q.empty())
		{

	} else { //--- RGB image
		RGBQUAD cRef = GetPixelColor(xStart,yStart);
		RGBQUAD cRefMin, cRefMax;
		cRefMin.rgbRed   = (BYTE)minimum(255, maximum(0,(int)(cRef.rgbRed   - nTolerance)));
		cRefMin.rgbGreen = (BYTE)minimum(255, maximum(0,(int)(cRef.rgbGreen - nTolerance)));
		cRefMin.rgbBlue  = (BYTE)minimum(255, maximum(0,(int)(cRef.rgbBlue  - nTolerance)));
		cRefMax.rgbRed   = (BYTE)minimum(255, maximum(0,(int)(cRef.rgbRed   + nTolerance)));
		cRefMax.rgbGreen = (BYTE)minimum(255, maximum(0,(int)(cRef.rgbGreen + nTolerance)));
		cRefMax.rgbBlue  = (BYTE)minimum(255, maximum(0,(int)(cRef.rgbBlue  + nTolerance)));

		while(!q.empty())
		{

Lines 460-466 bool CxImage::CreateFromArray(BYTE* pArray,DWORD dwWidth,DWORD dwHeight,DWORD dw Link Here

(-)a/lib/cximage-6.0/CxImage/ximage.cpp (-2 / +2 lines)
460	src+=4;	460	src+=4;
461	}	461	}
462	} else {	462	} else {
463	memcpy(dst,src,min(info.dwEffWidth,dwBytesperline));	463	memcpy(dst,src,minimum(info.dwEffWidth,dwBytesperline));
464	}	464	}
465	}	465	}
466	return true;	466	return true;
Lines 500-506 bool CxImage::CreateFromMatrix(BYTE** ppMatrix,DWORD dwWidth,DWORD dwHeight,DWOR Link Here
500	src+=4;	500	src+=4;
501	}	501	}
502	} else {	502	} else {
503	memcpy(dst,src,min(info.dwEffWidth,dwBytesperline));	503	memcpy(dst,src,minimum(info.dwEffWidth,dwBytesperline));
504	}	504	}
505	}	505	}
506	}	506	}




	ghost.EncodeHeader(fp);

	if (m_loops!=1){
		ghost.SetLoops(maximum(0,m_loops-1));
		ghost.EncodeLoopExtension(fp);
	}


////////////////////////////////////////////////////////////////////////////////
void CxImageGIF::GifMix(CxImage & imgsrc2, struct_image & imgdesc)
{
	long ymin = maximum(0,(long)(GetHeight()-imgdesc.t - imgdesc.h));
	long ymax = GetHeight()-imgdesc.t;
	long xmin = imgdesc.l;
	long xmax = minimum(GetWidth(), (DWORD)(imgdesc.l + imgdesc.w));

	long ibg2= imgsrc2.GetTransIndex();
    BYTE i2;




	// calculate LUT
	BYTE lut[256];
	for (x = 0; x <256; x++){
		lut[x] = (BYTE)maximum(0,minimum(255,(255 * (x - minc) / (maxc - minc))));
	}

	for (y=0; y<head.biHeight; y++)	{

		// calculate LUT
		BYTE lut[256];
		for (x = 0; x <256; x++){
			lut[x] = (BYTE)maximum(0,minimum(255,(255 * (x - minc) / (maxc - minc))));
		}

		// normalize image

		BYTE range = maxR - minR;
		if (range != 0)	{
			for (x = 0; x <256; x++){
				lutR[x] = (BYTE)maximum(0,minimum(255,(255 * (x - minR) / range)));
			}
		} else lutR[minR] = minR;


		range = maxG - minG;
		if (range != 0)	{
			for (x = 0; x <256; x++){
				lutG[x] = (BYTE)maximum(0,minimum(255,(255 * (x - minG) / range)));
			}
		} else lutG[minG] = minG;
			

		range = maxB - minB;
		if (range != 0)	{
			for (x = 0; x <256; x++){
				lutB[x] = (BYTE)maximum(0,minimum(255,(255 * (x - minB) / range)));
			}
		} else lutB[minB] = minB;


		// calculate LUT
		BYTE lut[256];
		for (x = 0; x <256; x++){
			lut[x] = (BYTE)maximum(0,minimum(255,(255 * (x - minc) / (maxc - minc))));
		}

		for(y=0; y<head.biHeight; y++){




  switch (ofMethod) {
    case OM_REPEAT:
      //clip coordinates
      x=maximum(x,0); x=minimum(x, head.biWidth-1);
      y=maximum(y,0); y=minimum(y, head.biHeight-1);
      break;
    case OM_WRAP:
      //wrap coordinates

  switch (ofMethod) {
    case OM_REPEAT:
      //clip coordinates
      x=maximum(x,0); x=minimum(x, head.biWidth-1);
      y=maximum(y,0); y=minimum(y, head.biHeight-1);
      break;
    case OM_WRAP:
      //wrap coordinates

Lines 140-146 inline void CImageIterator::SetY(int y) Link Here

(-)a/lib/cximage-6.0/CxImage/ximaiter.h (-2 / +2 lines)
140	inline void CImageIterator::SetRow(BYTE *buf, int n)	140	inline void CImageIterator::SetRow(BYTE *buf, int n)
141	{	141	{
142	if (n<0) n = (int)ima->GetEffWidth();	142	if (n<0) n = (int)ima->GetEffWidth();
143	else n = min(n,(int)ima->GetEffWidth());	143	else n = minimum(n,(int)ima->GetEffWidth());
144		144
145	if ((IterImage!=NULL)&&(buf!=NULL)&&(n>0)) memcpy(IterImage,buf,n);	145	if ((IterImage!=NULL)&&(buf!=NULL)&&(n>0)) memcpy(IterImage,buf,n);
146	}	146	}
Lines 148-154 inline void CImageIterator::SetRow(BYTE *buf, int n) Link Here
148	inline void CImageIterator::GetRow(BYTE *buf, int n)	148	inline void CImageIterator::GetRow(BYTE *buf, int n)
149	{	149	{
150	if ((IterImage!=NULL)&&(buf!=NULL)&&(n>0))	150	if ((IterImage!=NULL)&&(buf!=NULL)&&(n>0))
151	memcpy(buf,IterImage,min(n,(int)ima->GetEffWidth()));	151	memcpy(buf,IterImage,minimum(n,(int)ima->GetEffWidth()));
152	}	152	}
153	/////////////////////////////////////////////////////////////////////	153	/////////////////////////////////////////////////////////////////////
154	inline BYTE* CImageIterator::GetRow()	154	inline BYTE* CImageIterator::GetRow()

Lines 145-151 bool CxImageJBG::Encode(CxFile * hFile) Link Here

(-)a/lib/cximage-6.0/CxImage/ximajbg.cpp (-1 / +1 lines)
145	jbg_enc_init(&jbig_state, w, h, planes, &buffer, jbig_data_out, hFile);	145	jbg_enc_init(&jbig_state, w, h, planes, &buffer, jbig_data_out, hFile);
146		146
147	//jbg_enc_layers(&jbig_state, 2);	147	//jbg_enc_layers(&jbig_state, 2);
148	//jbg_enc_lrlmax(&jbig_state, 800, 600);	148	//jbg_enc_lrlmaximum(&jbig_state, 800, 600);
149		149
150	// Specify a few other options (each is ignored if negative)	150	// Specify a few other options (each is ignored if negative)
151	int dl = -1, dh = -1, d = -1, l0 = -1, mx = -1;	151	int dl = -1, dh = -1, d = -1, l0 = -1, mx = -1;

Lines 89-95 bool CxImageJPG::GetExifThumbnail(const char filename, const char outname, int Link Here

(-)a/lib/cximage-6.0/CxImage/ximajpg.cpp (-1 / +1 lines)
89	{	89	{
90	if (image.GetWidth() > 256 \|\| image.GetHeight() > 256)	90	if (image.GetWidth() > 256 \|\| image.GetHeight() > 256)
91	{ // resize the image	91	{ // resize the image
92	// float amount = 256.0f / max(image.GetWidth(), image.GetHeight());	92	// float amount = 256.0f / maximum(image.GetWidth(), image.GetHeight());
93	// image.Resample((long)(image.GetWidth() * amount), (long)(image.GetHeight() * amount), 0);	93	// image.Resample((long)(image.GetWidth() * amount), (long)(image.GetHeight() * amount), 0);
94	}	94	}
95	if (m_exifinfo.Orientation != 1)	95	if (m_exifinfo.Orientation != 1)




{
	if (buffer && (head.biClrUsed==0)){
		BYTE temp;
		length = minimum(length,(int)info.dwEffWidth);
		length = minimum(length,(int)(3*head.biWidth));
		for (int i=0;i<length;i+=3){
			temp = buffer[i]; buffer[i] = buffer[i+2]; buffer[i+2] = temp;
		}

	if (!g) g = r;
	if (!b) b = g;
	RGBQUAD* ppal=GetPalette();
	DWORD m=minimum(n,head.biClrUsed);
	for (DWORD i=0; i<m;i++){
		ppal[i].rgbRed=r[i];
		ppal[i].rgbGreen=g[i];

{
	if ((!rgb)||(pDib==NULL)||(head.biClrUsed==0)) return;
	RGBQUAD* ppal=GetPalette();
	DWORD m=minimum(nColors,head.biClrUsed);
	for (DWORD i=0; i<m;i++){
		ppal[i].rgbRed=rgb[i].r;
		ppal[i].rgbGreen=rgb[i].g;

void CxImage::SetPalette(RGBQUAD* pPal,DWORD nColors)
{
	if ((pPal==NULL)||(pDib==NULL)||(head.biClrUsed==0)) return;
	memcpy(GetPalette(),pPal,minimum(GetPaletteSize(),nColors*sizeof(RGBQUAD)));
	info.last_c_isvalid = false;
}
////////////////////////////////////////////////////////////////////////////////


	switch(head.biBitCount){
	case 1:
		head.biClrImportant = minimum(ncolors,2);
		break;
	case 4:
		head.biClrImportant = minimum(ncolors,16);
		break;
	case 8:
		head.biClrImportant = ncolors;




	} else SetGrayPalette(); //<DP> needed for grayscale PNGs
	
#ifdef USE_NEW_LIBPNG_API
	int nshift = maximum(0,(_bit_depth>>3)-1)<<3;
#else
	int nshift = maximum(0,(info_ptr->bit_depth>>3)-1)<<3;
#endif

#ifdef USE_NEW_LIBPNG_API

			if (pal){
				DWORD ip;
#ifdef USE_NEW_LIBPNG_API
				for (ip=0;ip<minimum(head.biClrUsed,(unsigned long)_num_trans);ip++)
					pal[ip].rgbReserved=_trans_alpha[ip];
#else
				for (ip=0;ip<minimum(head.biClrUsed,(unsigned long)info_ptr->num_trans);ip++)
#if PNG_LIBPNG_VER > 10399
					pal[ip].rgbReserved=info_ptr->trans_alpha[ip];
#else

#endif // CXIMAGE_SUPPORT_ALPHA	// <vho>

#ifdef USE_NEW_LIBPNG_API
	int row_size = maximum(info.dwEffWidth, (_width * _channels * _bit_depth / 8));
#else
	int row_size = maximum(info.dwEffWidth, info_ptr->width*info_ptr->channels*(info_ptr->bit_depth/8));
	info_ptr->rowbytes = row_size;
#endif
	BYTE *row_pointers = new BYTE[row_size];

Lines 216-222 bool CxImageRAW::Decode(CxFile *hFile) Link Here

(-)a/lib/cximage-6.0/CxImage/ximaraw.cpp (-2 / +2 lines)
216		216
217	DWORD size = dcr.width * (dcr.colors*dcr.opt.output_bps/8);	217	DWORD size = dcr.width * (dcr.colors*dcr.opt.output_bps/8);
218	RGBtoBGR(ppm,size);	218	RGBtoBGR(ppm,size);
219	memcpy(GetBits(dcr.height - 1 - row), ppm, min(size,GetEffWidth()));	219	memcpy(GetBits(dcr.height - 1 - row), ppm, minimum(size,GetEffWidth()));
220	}	220	}
221	free (ppm);	221	free (ppm);
222		222
Lines 298-304 bool CxImageRAW::GetExifThumbnail(const char filename, const char outname, int Link Here
298	// Resizing.	298	// Resizing.
299	if (image.GetWidth() > 256 \|\| image.GetHeight() > 256)	299	if (image.GetWidth() > 256 \|\| image.GetHeight() > 256)
300	{	300	{
301	float amount = 256.0f / max(image.GetWidth(), image.GetHeight());	301	float amount = 256.0f / maximum(image.GetWidth(), image.GetHeight());
302	image.Resample((long)(image.GetWidth() * amount), (long)(image.GetHeight() * amount), 0);	302	image.Resample((long)(image.GetWidth() * amount), (long)(image.GetHeight() * amount), 0);
303	}	303	}
304		304




	if (r.left<r.right) {r2.left=r.left; r2.right=r.right; } else {r2.left=r.right ; r2.right=r.left; }
	if (r.bottom<r.top) {r2.bottom=r.bottom; r2.top=r.top; } else {r2.bottom=r.top ; r2.top=r.bottom; }

	if (info.rSelectionBox.top <= r2.top) info.rSelectionBox.top = maximum(0L,minimum(head.biHeight,r2.top+1));
	if (info.rSelectionBox.left > r2.left) info.rSelectionBox.left = maximum(0L,minimum(head.biWidth,r2.left));
	if (info.rSelectionBox.right <= r2.right) info.rSelectionBox.right = maximum(0L,minimum(head.biWidth,r2.right+1));
	if (info.rSelectionBox.bottom > r2.bottom) info.rSelectionBox.bottom = maximum(0L,minimum(head.biHeight,r2.bottom));

	long ymin = maximum(0L,minimum(head.biHeight,r2.bottom));
	long ymax = maximum(0L,minimum(head.biHeight,r2.top+1));
	long xmin = maximum(0L,minimum(head.biWidth,r2.left));
	long xmax = maximum(0L,minimum(head.biWidth,r2.right+1));

	for (long y=ymin; y<ymax; y++)
		memset(pSelection + xmin + y * head.biWidth, level, xmax-xmin);

	long xcenter = (r.right + r.left)/2;
	long ycenter = (r.top + r.bottom)/2;

	if (info.rSelectionBox.left > (xcenter - xradius)) info.rSelectionBox.left = maximum(0L,minimum(head.biWidth,(xcenter - xradius)));
	if (info.rSelectionBox.right <= (xcenter + xradius)) info.rSelectionBox.right = maximum(0L,minimum(head.biWidth,(xcenter + xradius + 1)));
	if (info.rSelectionBox.bottom > (ycenter - yradius)) info.rSelectionBox.bottom = maximum(0L,minimum(head.biHeight,(ycenter - yradius)));
	if (info.rSelectionBox.top <= (ycenter + yradius)) info.rSelectionBox.top = maximum(0L,minimum(head.biHeight,(ycenter + yradius + 1)));

	long xmin = maximum(0L,minimum(head.biWidth,xcenter - xradius));
	long xmax = maximum(0L,minimum(head.biWidth,xcenter + xradius + 1));
	long ymin = maximum(0L,minimum(head.biHeight,ycenter - yradius));
	long ymax = maximum(0L,minimum(head.biHeight,ycenter + yradius + 1));

	long y,yo;
	for (y=ymin; y<minimum(ycenter,ymax); y++){
		for (long x=xmin; x<xmax; x++){
			yo = (long)(ycenter - yradius * sqrt(1-pow((float)(x - xcenter)/(float)xradius,2)));
			if (yo<y) pSelection[x + y * head.biWidth] = level;

		RECT r2;
		if (current->x < next->x) {r2.left=current->x; r2.right=next->x; } else {r2.left=next->x ; r2.right=current->x; }
		if (current->y < next->y) {r2.bottom=current->y; r2.top=next->y; } else {r2.bottom=next->y ; r2.top=current->y; }
		if (localbox.top < r2.top) localbox.top = maximum(0L,minimum(head.biHeight-1,r2.top+1));
		if (localbox.left > r2.left) localbox.left = maximum(0L,minimum(head.biWidth-1,r2.left-1));
		if (localbox.right < r2.right) localbox.right = maximum(0L,minimum(head.biWidth-1,r2.right+1));
		if (localbox.bottom > r2.bottom) localbox.bottom = maximum(0L,minimum(head.biHeight-1,r2.bottom-1));

		i++;
	}

		for (x=localbox.left; x<=localbox.right; x++)
			if (plocal[x + yoffset]!=1) pSelection[x + yoffset]=level;
	}
	if (info.rSelectionBox.top <= localbox.top) info.rSelectionBox.top = minimum(head.biHeight,localbox.top + 1);
	if (info.rSelectionBox.left > localbox.left) info.rSelectionBox.left = minimum(head.biWidth,localbox.left);
	if (info.rSelectionBox.right <= localbox.right) info.rSelectionBox.right = minimum(head.biWidth,localbox.right + 1);
	if (info.rSelectionBox.bottom > localbox.bottom) info.rSelectionBox.bottom = minimum(head.biHeight,localbox.bottom);

	free(plocal);
	free(pix);

Lines 64-73 CxRect2 CxRect2::CrossSection(CxRect2 const &r2) const Link Here

(-)a/lib/cximage-6.0/CxImage/ximath.cpp (-4 / +4 lines)
64	*/	64	*/
65	{	65	{
66	CxRect2 cs;	66	CxRect2 cs;
67	cs.botLeft.x=max(botLeft.x, r2.botLeft.x);	67	cs.botLeft.x=maximum(botLeft.x, r2.botLeft.x);
68	cs.botLeft.y=max(botLeft.y, r2.botLeft.y);	68	cs.botLeft.y=maximum(botLeft.y, r2.botLeft.y);
69	cs.topRight.x=min(topRight.x, r2.topRight.x);	69	cs.topRight.x=minimum(topRight.x, r2.topRight.x);
70	cs.topRight.y=min(topRight.y, r2.topRight.y);	70	cs.topRight.y=minimum(topRight.y, r2.topRight.y);
71	if (cs.botLeft.x<=cs.topRight.x && cs.botLeft.y<=cs.topRight.y) {	71	if (cs.botLeft.x<=cs.topRight.x && cs.botLeft.y<=cs.topRight.y) {
72	return cs;	72	return cs;
73	} else {	73	} else {

Lines 470-478 bool CxImageTIF::Decode(CxFile * hFile) Link Here

(-)a/lib/cximage-6.0/CxImage/ximatif.cpp (-3 / +3 lines)
470	if ( cb > 0.00304 ) cb = 1.055 * pow(cb,0.41667) - 0.055;	470	if ( cb > 0.00304 ) cb = 1.055 * pow(cb,0.41667) - 0.055;
471	else cb = 12.92 * cb;	471	else cb = 12.92 * cb;
472		472
473	c.rgbRed =(BYTE)max(0,min(255,(int)(cr*255)));	473	c.rgbRed =(BYTE)maximum(0,minimum(255,(int)(cr*255)));
474	c.rgbGreen=(BYTE)max(0,min(255,(int)(cg*255)));	474	c.rgbGreen=(BYTE)maximum(0,minimum(255,(int)(cg*255)));
475	c.rgbBlue =(BYTE)max(0,min(255,(int)(cb*255)));	475	c.rgbBlue =(BYTE)maximum(0,minimum(255,(int)(cb*255)));
476		476
477	SetPixelColor(xi,yi,c);	477	SetPixelColor(xi,yi,c);
478	#if CXIMAGE_SUPPORT_ALPHA	478	#if CXIMAGE_SUPPORT_ALPHA




			for (ys = 0; ys < newHeight; ys+=RBLOCK) {
				if (head.biBitCount==24) {
					//RGB24 optimized pixel access:
					for (x = xs; x < minimum(newWidth, xs+RBLOCK); x++){    //do rotation
						info.nProgress = (long)(100*x/newWidth);
						x2=newWidth-x-1;
						dstPtr = (BYTE*) imgDest.BlindGetPixelPointer(x,ys);
						srcPtr = (BYTE*) BlindGetPixelPointer(ys, x2);
						for (y = ys; y < minimum(newHeight, ys+RBLOCK); y++){
							//imgDest.SetPixelColor(x, y, GetPixelColor(y, x2));
							*(dstPtr) = *(srcPtr);
							*(dstPtr+1) = *(srcPtr+1);

					}//for x
				} else {
					//anything else than 24bpp (and 1bpp): palette
					for (x = xs; x < minimum(newWidth, xs+RBLOCK); x++){
						info.nProgress = (long)(100*x/newWidth); //<Anatoly Ivasyuk>
						x2=newWidth-x-1;
						for (y = ys; y < minimum(newHeight, ys+RBLOCK); y++){
							imgDest.SetPixelIndex(x, y, BlindGetPixelIndex(y, x2));
						}//for y
					}//for x
				}//if (version selection)
#if CXIMAGE_SUPPORT_ALPHA
				if (AlphaIsValid()) {
					for (x = xs; x < minimum(newWidth, xs+RBLOCK); x++){
						x2=newWidth-x-1;
						for (y = ys; y < minimum(newHeight, ys+RBLOCK); y++){
							imgDest.AlphaSet(x,y,BlindAlphaGet(y, x2));
						}//for y
					}//for x

					imgDest.info.rSelectionBox.right = newWidth-info.rSelectionBox.bottom;
					imgDest.info.rSelectionBox.bottom = info.rSelectionBox.left;
					imgDest.info.rSelectionBox.top = info.rSelectionBox.right;
					for (x = xs; x < minimum(newWidth, xs+RBLOCK); x++){
						x2=newWidth-x-1;
						for (y = ys; y < minimum(newHeight, ys+RBLOCK); y++){
							imgDest.SelectionSet(x,y,BlindSelectionGet(y, x2));
						}//for y
					}//for x

			for (ys = 0; ys < newHeight; ys+=RBLOCK) {
				if (head.biBitCount==24) {
					//RGB24 optimized pixel access:
					for (y = ys; y < minimum(newHeight, ys+RBLOCK); y++){
						info.nProgress = (long)(100*y/newHeight); //<Anatoly Ivasyuk>
						y2=newHeight-y-1;
						dstPtr = (BYTE*) imgDest.BlindGetPixelPointer(xs,y);
						srcPtr = (BYTE*) BlindGetPixelPointer(y2, xs);
						for (x = xs; x < minimum(newWidth, xs+RBLOCK); x++){
							//imgDest.SetPixelColor(x, y, GetPixelColor(y2, x));
							*(dstPtr) = *(srcPtr);
							*(dstPtr+1) = *(srcPtr+1);

					}//for y
				} else {
					//anything else than BW & RGB24: palette
					for (y = ys; y < minimum(newHeight, ys+RBLOCK); y++){
						info.nProgress = (long)(100*y/newHeight); //<Anatoly Ivasyuk>
						y2=newHeight-y-1;
						for (x = xs; x < minimum(newWidth, xs+RBLOCK); x++){
							imgDest.SetPixelIndex(x, y, BlindGetPixelIndex(y2, x));
						}//for x
					}//for y
				}//if
#if CXIMAGE_SUPPORT_ALPHA
				if (AlphaIsValid()){
					for (y = ys; y < minimum(newHeight, ys+RBLOCK); y++){
						y2=newHeight-y-1;
						for (x = xs; x < minimum(newWidth, xs+RBLOCK); x++){
							imgDest.AlphaSet(x,y,BlindAlphaGet(y2, x));
						}//for x
					}//for y

					imgDest.info.rSelectionBox.right = info.rSelectionBox.top;
					imgDest.info.rSelectionBox.bottom = newHeight-info.rSelectionBox.right;
					imgDest.info.rSelectionBox.top = newHeight-info.rSelectionBox.left;
					for (y = ys; y < minimum(newHeight, ys+RBLOCK); y++){
						y2=newHeight-y-1;
						for (x = xs; x < minimum(newWidth, xs+RBLOCK); x++){
							imgDest.SelectionSet(x,y,BlindSelectionGet(y2, x));
						}//for x
					}//for y

	newP4.x = (float)(p4.x*cos_angle - p4.y*sin_angle);
	newP4.y = (float)(p4.x*sin_angle + p4.y*cos_angle);

	leftTop.x = minimum(minimum(newP1.x,newP2.x),minimum(newP3.x,newP4.x));
	leftTop.y = minimum(minimum(newP1.y,newP2.y),minimum(newP3.y,newP4.y));
	rightBottom.x = maximum(maximum(newP1.x,newP2.x),maximum(newP3.x,newP4.x));
	rightBottom.y = maximum(maximum(newP1.y,newP2.y),maximum(newP3.y,newP4.y));
	leftBottom.x = leftTop.x;
	leftBottom.y = rightBottom.y;
	rightTop.x = rightBottom.x;

	}//if

	//(read new dimensions from location of corners)
	float minx = (float) minimum(minimum(newp[0].x,newp[1].x),minimum(newp[2].x,newp[3].x));
	float miny = (float) minimum(minimum(newp[0].y,newp[1].y),minimum(newp[2].y,newp[3].y));
	float maxx = (float) maximum(maximum(newp[0].x,newp[1].x),maximum(newp[2].x,newp[3].x));
	float maxy = (float) maximum(maximum(newp[0].y,newp[1].y),maximum(newp[2].y,newp[3].y));
	int newWidth = (int) floor(maxx-minx+0.5f);
	int newHeight= (int) floor(maxy-miny+0.5f);
	float ssx=((maxx+minx)- ((float) newWidth-1))/2.0f;   //start for x

				if (info.nEscape) break;
				fY = y * yScale;
				ifY = (int)fY;
				ifY1 = minimum(ymax, ifY+1);
				dy = fY - ifY;
				for(long x=0; x<newx; x++){
					fX = x * xScale;
					ifX = (int)fX;
					ifX1 = minimum(xmax, ifX+1);
					dx = fX - ifX;
					// Interpolate using the four nearest pixels in the source
					if (head.biClrUsed){

				eb=(long)c.rgbBlue - (long)ce.rgbBlue;

				c = GetPixelColor(x+1,y);
				c.rgbRed = (BYTE)minimum(255L,maximum(0L,(long)c.rgbRed + ((er*7)/16)));
				c.rgbGreen = (BYTE)minimum(255L,maximum(0L,(long)c.rgbGreen + ((eg*7)/16)));
				c.rgbBlue = (BYTE)minimum(255L,maximum(0L,(long)c.rgbBlue + ((eb*7)/16)));
				SetPixelColor(x+1,y,c);
				int coeff=1;
				for(int i=-1; i<2; i++){

						coeff=1; break;
					}
					c = GetPixelColor(x+i,y+1);
					c.rgbRed = (BYTE)minimum(255L,maximum(0L,(long)c.rgbRed + ((er * coeff)/16)));
					c.rgbGreen = (BYTE)minimum(255L,maximum(0L,(long)c.rgbGreen + ((eg * coeff)/16)));
					c.rgbBlue = (BYTE)minimum(255L,maximum(0L,(long)c.rgbBlue + ((eb * coeff)/16)));
					SetPixelColor(x+i,y+1,c);
				}
			}

				}

				nlevel = GetPixelIndex(x + 1, y) + (error * 8) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(x + 1, y, level);
				nlevel = GetPixelIndex(x + 2, y) + (error * 4) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(x + 2, y, level);
				int i;
				for (i = -2; i < 3; i++) {

						break;
					}
					nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
					level = (BYTE)minimum(255, maximum(0, (int)nlevel));
					SetPixelIndex(x + i, y + 1, level);
				}
			}

				}

				nlevel = GetPixelIndex(x + 1, y) + (error * 8) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(x + 1, y, level);
				nlevel = GetPixelIndex(x + 2, y) + (error * 4) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(x + 2, y, level);
				int i;
				for (i = -2; i < 3; i++) {

						break;
					}
					nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
					level = (BYTE)minimum(255, maximum(0, (int)nlevel));
					SetPixelIndex(x + i, y + 1, level);
				}
				for (i = -2; i < 3; i++) {

						break;
					}
					nlevel = GetPixelIndex(x + i, y + 2) + (error * coeff) / TotalCoeffSum;
					level = (BYTE)minimum(255, maximum(0, (int)nlevel));
					SetPixelIndex(x + i, y + 2, level);
				}
			}

				}

				nlevel = GetPixelIndex(x + 1, y) + (error * 7) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(x + 1, y, level);
				nlevel = GetPixelIndex(x + 2, y) + (error * 5) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(x + 2, y, level);
				int i;
				for (i = -2; i < 3; i++) {

						break;
					}
					nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
					level = (BYTE)minimum(255, maximum(0, (int)nlevel));
					SetPixelIndex(x + i, y + 1, level);
				}
				for (i = -2; i < 3; i++) {

						break;
					}
					nlevel = GetPixelIndex(x + i, y + 2) + (error * coeff) / TotalCoeffSum;
					level = (BYTE)minimum(255, maximum(0, (int)nlevel));
					SetPixelIndex(x + i, y + 2, level);
				}
			}

				}

				nlevel = GetPixelIndex(x + 1, y) + (error * 5) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(x + 1, y, level);
				nlevel = GetPixelIndex(x + 2, y) + (error * 3) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(x + 2, y, level);
				int i;
				for (i = -2; i < 3; i++) {

						break;
					}
					nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
					level = (BYTE)minimum(255, maximum(0, (int)nlevel));
					SetPixelIndex(x + i, y + 1, level);
				}
				for (i = -1; i < 2; i++) {

						break;
					}
					nlevel = GetPixelIndex(x + i, y + 2) + (error * coeff) / TotalCoeffSum;
					level = (BYTE)minimum(255, maximum(0, (int)nlevel));
					SetPixelIndex(x + i, y + 2, level);
				}
			}

				int tmp_index_y = y;
				int tmp_coeff = 32;
				nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(tmp_index_x, tmp_index_y, level);

				tmp_index_x = x - 3;
				tmp_index_y = y + 1;
				tmp_coeff = 12;
				nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(tmp_index_x, tmp_index_y, level);

				tmp_index_x = x - 1;
				tmp_coeff = 26;
				nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(tmp_index_x, tmp_index_y, level);

				tmp_index_x = x + 1;
				tmp_coeff = 30;
				nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(tmp_index_x, tmp_index_y, level);

				tmp_index_x = x + 3;
				tmp_coeff = 16;
				nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(tmp_index_x, tmp_index_y, level);

				tmp_index_x = x - 2;
				tmp_index_y = y + 2;
				tmp_coeff = 12;
				nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(tmp_index_x, tmp_index_y, level);

				tmp_index_x = x;
				tmp_coeff = 26;
				nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(tmp_index_x, tmp_index_y, level);

				tmp_index_x = x + 2;
				tmp_coeff = 12;
				nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(tmp_index_x, tmp_index_y, level);

				tmp_index_x = x - 3;
				tmp_index_y = y + 3;
				tmp_coeff = 5;
				nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(tmp_index_x, tmp_index_y, level);

				tmp_index_x = x - 1;
				tmp_coeff = 12;
				nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(tmp_index_x, tmp_index_y, level);

				tmp_index_x = x + 1;
				tmp_coeff = 12;
				nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(tmp_index_x, tmp_index_y, level);

				tmp_index_x = x + 3;
				tmp_coeff = 5;
				nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
				level = (BYTE)minimum(255, maximum(0, (int)nlevel));
				SetPixelIndex(tmp_index_x, tmp_index_y, level);
			}
		}

			Bmatrix[i] = (BYTE)(dither);
		}

		int scale = maximum(0,(8-2*order));
		int level;
		for (long y=0;y<head.biHeight;y++){
			info.nProgress = (long)(100*y/head.biHeight);

				}

				nlevel = GetPixelIndex(x+1,y) + (error * 7)/16;
				level = (BYTE)minimum(255,maximum(0,(int)nlevel));
				SetPixelIndex(x+1,y,level);
				for(int i=-1; i<2; i++){
					switch(i){

						coeff=1; break;
					}
					nlevel = GetPixelIndex(x+i,y+1) + (error * coeff)/16;
					level = (BYTE)minimum(255,maximum(0,(int)nlevel));
					SetPixelIndex(x+i,y+1,level);
				}
			}

	if ( fabs(angle)<0.0002 )
		return Crop( topx, topy, topx+width, topy+height, iDst);

	startx = minimum(topx, topx - (long)(sin_angle*(double)height));
	endx   = topx + (long)(cos_angle*(double)width);
	endy   = topy + (long)(cos_angle*(double)height + sin_angle*(double)width);
	// check: corners of the rectangle must be inside

{
	if (!pDib) return false;

	long startx = maximum(0L,minimum(left,head.biWidth));
	long endx = maximum(0L,minimum(right,head.biWidth));
	long starty = head.biHeight - maximum(0L,minimum(top,head.biHeight));
	long endy = head.biHeight - maximum(0L,minimum(bottom,head.biHeight));

	if (startx==endx || starty==endy) return false;


						nx=x+(x%32)-16;
						ny=y;
					}
//					nx=maximum(xmin,minimum(nx,xmax));
//					ny=maximum(ymin,minimum(ny,ymax));
				}
				else { nx=-1;ny=-1;}
				if (head.biClrUsed==0){




	RECT clipbox,paintbox;
	GetClipBox(hdc,&clipbox);

	paintbox.top = minimum(clipbox.bottom,maximum(clipbox.top,y));
	paintbox.left = minimum(clipbox.right,maximum(clipbox.left,x));
	paintbox.right = maximum(clipbox.left,minimum(clipbox.right,x+cx));
	paintbox.bottom = maximum(clipbox.top,minimum(clipbox.bottom,y+cy));

	long destw = paintbox.right - paintbox.left;
	long desth = paintbox.bottom - paintbox.top;


				for(yy=0;yy<desth;yy++){
					dy = head.biHeight-(ymax-yy-y)*fy;
					sy = maximum(0L,(long)floor(dy));
					psrc = info.pImage+sy*info.dwEffWidth;
					pdst = pbase+yy*ew;
					for(xx=0;xx<destw;xx++){
						dx = (xx+xmin-x)*fx;
						sx = maximum(0L,(long)floor(dx));
#if CXIMAGE_SUPPORT_INTERPOLATION
						if (bSmooth){
							if (fx > 1 && fy > 1) { 

				
				for(yy=0;yy<desth;yy++){
					dy = head.biHeight-(ymax-yy-y)*fy;
					sy = maximum(0L,(long)floor(dy));

					alphaoffset = sy*head.biWidth;
					pdst = pbase + yy*ew;


					for(xx=0;xx<destw;xx++){
						dx = (xx+xmin-x)*fx;
						sx = maximum(0L,(long)floor(dx));

						if (bAlpha) a=pAlpha[alphaoffset+sx]; else a=255;
						a =(BYTE)((a*(1+info.nAlphaMax))>>8);

Return to bug 592446

Lines 478-484 bool CxImageGIF::Encode(CxFile * fp, CxImage ** pImages, int pagecount, bool bLo Link Here

(-)a/lib/cximage-6.0/CxImage/ximagif.cpp (-3 / +3 lines)
478	ghost.EncodeHeader(fp);	478	ghost.EncodeHeader(fp);
479		479
480	if (m_loops!=1){	480	if (m_loops!=1){
481	ghost.SetLoops(max(0,m_loops-1));	481	ghost.SetLoops(maximum(0,m_loops-1));
482	ghost.EncodeLoopExtension(fp);	482	ghost.EncodeLoopExtension(fp);
483	}	483	}
484		484
Lines 1340-1349 void CxImageGIF::GetComment(char* sz_comment_out) Link Here
1340	////////////////////////////////////////////////////////////////////////////////	1340	////////////////////////////////////////////////////////////////////////////////
1341	void CxImageGIF::GifMix(CxImage & imgsrc2, struct_image & imgdesc)	1341	void CxImageGIF::GifMix(CxImage & imgsrc2, struct_image & imgdesc)
1342	{	1342	{
1343	long ymin = max(0,(long)(GetHeight()-imgdesc.t - imgdesc.h));	1343	long ymin = maximum(0,(long)(GetHeight()-imgdesc.t - imgdesc.h));
1344	long ymax = GetHeight()-imgdesc.t;	1344	long ymax = GetHeight()-imgdesc.t;
1345	long xmin = imgdesc.l;	1345	long xmin = imgdesc.l;
1346	long xmax = min(GetWidth(), (DWORD)(imgdesc.l + imgdesc.w));	1346	long xmax = minimum(GetWidth(), (DWORD)(imgdesc.l + imgdesc.w));
1347		1347
1348	long ibg2= imgsrc2.GetTransIndex();	1348	long ibg2= imgsrc2.GetTransIndex();
1349	BYTE i2;	1349	BYTE i2;

Lines 110-116 bool CxImage::HistogramStretch(long method, double threshold) Link Here

(-)a/lib/cximage-6.0/CxImage/ximahist.cpp (-6 / +6 lines)
110	// calculate LUT	110	// calculate LUT
111	BYTE lut[256];	111	BYTE lut[256];
112	for (x = 0; x <256; x++){	112	for (x = 0; x <256; x++){
113	lut[x] = (BYTE)max(0,min(255,(255 * (x - minc) / (maxc - minc))));	113	lut[x] = (BYTE)maximum(0,minimum(255,(255 * (x - minc) / (maxc - minc))));
114	}	114	}
115		115
116	for (y=0; y<head.biHeight; y++) {	116	for (y=0; y<head.biHeight; y++) {
Lines 152-158 bool CxImage::HistogramStretch(long method, double threshold) Link Here
152	// calculate LUT	152	// calculate LUT
153	BYTE lut[256];	153	BYTE lut[256];
154	for (x = 0; x <256; x++){	154	for (x = 0; x <256; x++){
155	lut[x] = (BYTE)max(0,min(255,(255 * (x - minc) / (maxc - minc))));	155	lut[x] = (BYTE)maximum(0,minimum(255,(255 * (x - minc) / (maxc - minc))));
156	}	156	}
157		157
158	// normalize image	158	// normalize image
Lines 225-231 bool CxImage::HistogramStretch(long method, double threshold) Link Here
225	BYTE range = maxR - minR;	225	BYTE range = maxR - minR;
226	if (range != 0) {	226	if (range != 0) {
227	for (x = 0; x <256; x++){	227	for (x = 0; x <256; x++){
228	lutR[x] = (BYTE)max(0,min(255,(255 * (x - minR) / range)));	228	lutR[x] = (BYTE)maximum(0,minimum(255,(255 * (x - minR) / range)));
229	}	229	}
230	} else lutR[minR] = minR;	230	} else lutR[minR] = minR;
231		231
Lines 233-239 bool CxImage::HistogramStretch(long method, double threshold) Link Here
233	range = maxG - minG;	233	range = maxG - minG;
234	if (range != 0) {	234	if (range != 0) {
235	for (x = 0; x <256; x++){	235	for (x = 0; x <256; x++){
236	lutG[x] = (BYTE)max(0,min(255,(255 * (x - minG) / range)));	236	lutG[x] = (BYTE)maximum(0,minimum(255,(255 * (x - minG) / range)));
237	}	237	}
238	} else lutG[minG] = minG;	238	} else lutG[minG] = minG;
239		239
Lines 241-247 bool CxImage::HistogramStretch(long method, double threshold) Link Here
241	range = maxB - minB;	241	range = maxB - minB;
242	if (range != 0) {	242	if (range != 0) {
243	for (x = 0; x <256; x++){	243	for (x = 0; x <256; x++){
244	lutB[x] = (BYTE)max(0,min(255,(255 * (x - minB) / range)));	244	lutB[x] = (BYTE)maximum(0,minimum(255,(255 * (x - minB) / range)));
245	}	245	}
246	} else lutB[minB] = minB;	246	} else lutB[minB] = minB;
247		247
Lines 292-298 bool CxImage::HistogramStretch(long method, double threshold) Link Here
292	// calculate LUT	292	// calculate LUT
293	BYTE lut[256];	293	BYTE lut[256];
294	for (x = 0; x <256; x++){	294	for (x = 0; x <256; x++){
295	lut[x] = (BYTE)max(0,min(255,(255 * (x - minc) / (maxc - minc))));	295	lut[x] = (BYTE)maximum(0,minimum(255,(255 * (x - minc) / (maxc - minc))));
296	}	296	}
297		297
298	for(y=0; y<head.biHeight; y++){	298	for(y=0; y<head.biHeight; y++){

Lines 206-214 bool CxImagePNG::Decode(CxFile *hFile) Link Here

(-)a/lib/cximage-6.0/CxImage/ximapng.cpp (-6 / +6 lines)
206	} else SetGrayPalette(); //<DP> needed for grayscale PNGs	206	} else SetGrayPalette(); //<DP> needed for grayscale PNGs
207		207
208	#ifdef USE_NEW_LIBPNG_API	208	#ifdef USE_NEW_LIBPNG_API
209	int nshift = max(0,(_bit_depth>>3)-1)<<3;	209	int nshift = maximum(0,(_bit_depth>>3)-1)<<3;
210	#else	210	#else
211	int nshift = max(0,(info_ptr->bit_depth>>3)-1)<<3;	211	int nshift = maximum(0,(info_ptr->bit_depth>>3)-1)<<3;
212	#endif	212	#endif
213		213
214	#ifdef USE_NEW_LIBPNG_API	214	#ifdef USE_NEW_LIBPNG_API
Lines 255-264 bool CxImagePNG::Decode(CxFile *hFile) Link Here
255	if (pal){	255	if (pal){
256	DWORD ip;	256	DWORD ip;
257	#ifdef USE_NEW_LIBPNG_API	257	#ifdef USE_NEW_LIBPNG_API
258	for (ip=0;ip<min(head.biClrUsed,(unsigned long)_num_trans);ip++)	258	for (ip=0;ip<minimum(head.biClrUsed,(unsigned long)_num_trans);ip++)
259	pal[ip].rgbReserved=_trans_alpha[ip];	259	pal[ip].rgbReserved=_trans_alpha[ip];
260	#else	260	#else
261	for (ip=0;ip<min(head.biClrUsed,(unsigned long)info_ptr->num_trans);ip++)	261	for (ip=0;ip<minimum(head.biClrUsed,(unsigned long)info_ptr->num_trans);ip++)
262	#if PNG_LIBPNG_VER > 10399	262	#if PNG_LIBPNG_VER > 10399
263	pal[ip].rgbReserved=info_ptr->trans_alpha[ip];	263	pal[ip].rgbReserved=info_ptr->trans_alpha[ip];
264	#else	264	#else
Lines 737-745 bool CxImagePNG::Encode(CxFile *hFile) Link Here
737	#endif // CXIMAGE_SUPPORT_ALPHA // <vho>	737	#endif // CXIMAGE_SUPPORT_ALPHA // <vho>
738		738
739	#ifdef USE_NEW_LIBPNG_API	739	#ifdef USE_NEW_LIBPNG_API
740	int row_size = max(info.dwEffWidth, (_width * _channels * _bit_depth / 8));	740	int row_size = maximum(info.dwEffWidth, (_width * _channels * _bit_depth / 8));
741	#else	741	#else
742	int row_size = max(info.dwEffWidth, info_ptr->widthinfo_ptr->channels(info_ptr->bit_depth/8));	742	int row_size = maximum(info.dwEffWidth, info_ptr->widthinfo_ptr->channels(info_ptr->bit_depth/8));
743	info_ptr->rowbytes = row_size;	743	info_ptr->rowbytes = row_size;
744	#endif	744	#endif
745	BYTE *row_pointers = new BYTE[row_size];	745	BYTE *row_pointers = new BYTE[row_size];

Lines 682-691 long CxImage::Draw(HDC hdc, long x, long y, long cx, long cy, RECT* pClipRect, b Link Here

(-)a/lib/cximage-6.0/CxImage/ximawnd.cpp (-8 / +8 lines)
682	RECT clipbox,paintbox;	682	RECT clipbox,paintbox;
683	GetClipBox(hdc,&clipbox);	683	GetClipBox(hdc,&clipbox);
684		684
685	paintbox.top = min(clipbox.bottom,max(clipbox.top,y));	685	paintbox.top = minimum(clipbox.bottom,maximum(clipbox.top,y));
686	paintbox.left = min(clipbox.right,max(clipbox.left,x));	686	paintbox.left = minimum(clipbox.right,maximum(clipbox.left,x));
687	paintbox.right = max(clipbox.left,min(clipbox.right,x+cx));	687	paintbox.right = maximum(clipbox.left,minimum(clipbox.right,x+cx));
688	paintbox.bottom = max(clipbox.top,min(clipbox.bottom,y+cy));	688	paintbox.bottom = maximum(clipbox.top,minimum(clipbox.bottom,y+cy));
689		689
690	long destw = paintbox.right - paintbox.left;	690	long destw = paintbox.right - paintbox.left;
691	long desth = paintbox.bottom - paintbox.top;	691	long desth = paintbox.bottom - paintbox.top;
Lines 730-741 long CxImage::Draw(HDC hdc, long x, long y, long cx, long cy, RECT* pClipRect, b Link Here
730		730
731	for(yy=0;yy<desth;yy++){	731	for(yy=0;yy<desth;yy++){
732	dy = head.biHeight-(ymax-yy-y)*fy;	732	dy = head.biHeight-(ymax-yy-y)*fy;
733	sy = max(0L,(long)floor(dy));	733	sy = maximum(0L,(long)floor(dy));
734	psrc = info.pImage+sy*info.dwEffWidth;	734	psrc = info.pImage+sy*info.dwEffWidth;
735	pdst = pbase+yy*ew;	735	pdst = pbase+yy*ew;
736	for(xx=0;xx<destw;xx++){	736	for(xx=0;xx<destw;xx++){
737	dx = (xx+xmin-x)*fx;	737	dx = (xx+xmin-x)*fx;
738	sx = max(0L,(long)floor(dx));	738	sx = maximum(0L,(long)floor(dx));
739	#if CXIMAGE_SUPPORT_INTERPOLATION	739	#if CXIMAGE_SUPPORT_INTERPOLATION
740	if (bSmooth){	740	if (bSmooth){
741	if (fx > 1 && fy > 1) {	741	if (fx > 1 && fy > 1) {
Lines 813-819 long CxImage::Draw(HDC hdc, long x, long y, long cx, long cy, RECT* pClipRect, b Link Here
813		813
814	for(yy=0;yy<desth;yy++){	814	for(yy=0;yy<desth;yy++){
815	dy = head.biHeight-(ymax-yy-y)*fy;	815	dy = head.biHeight-(ymax-yy-y)*fy;
816	sy = max(0L,(long)floor(dy));	816	sy = maximum(0L,(long)floor(dy));
817		817
818	alphaoffset = sy*head.biWidth;	818	alphaoffset = sy*head.biWidth;
819	pdst = pbase + yy*ew;	819	pdst = pbase + yy*ew;
Lines 821-827 long CxImage::Draw(HDC hdc, long x, long y, long cx, long cy, RECT* pClipRect, b Link Here
821		821
822	for(xx=0;xx<destw;xx++){	822	for(xx=0;xx<destw;xx++){
823	dx = (xx+xmin-x)*fx;	823	dx = (xx+xmin-x)*fx;
824	sx = max(0L,(long)floor(dx));	824	sx = maximum(0L,(long)floor(dx));
825		825
826	if (bAlpha) a=pAlpha[alphaoffset+sx]; else a=255;	826	if (bAlpha) a=pAlpha[alphaoffset+sx]; else a=255;
827	a =(BYTE)((a*(1+info.nAlphaMax))>>8);	827	a =(BYTE)((a*(1+info.nAlphaMax))>>8);

Lines 46-52 bool CxImageBMP::Encode(CxFile * hFile) Link Here

(-)a/lib/cximage-6.0/CxImage/ximabmp.cpp (-3 / +3 lines)
46	bihtoh(&infohdr);	46	bihtoh(&infohdr);
47		47
48	// Write the file header	48	// Write the file header
49	hFile->Write(&hdr,min(14,sizeof(BITMAPFILEHEADER)),1);	49	hFile->Write(&hdr,minimum(14,sizeof(BITMAPFILEHEADER)),1);
50	hFile->Write(&infohdr,sizeof(BITMAPINFOHEADER),1);	50	hFile->Write(&infohdr,sizeof(BITMAPINFOHEADER),1);
51	//and DIB+ALPHA interlaced	51	//and DIB+ALPHA interlaced
52	BYTE *srcalpha = AlphaGetPointer();	52	BYTE *srcalpha = AlphaGetPointer();
Lines 64-70 bool CxImageBMP::Encode(CxFile * hFile) Link Here
64	#endif //CXIMAGE_SUPPORT_ALPHA	64	#endif //CXIMAGE_SUPPORT_ALPHA
65	{	65	{
66	// Write the file header	66	// Write the file header
67	hFile->Write(&hdr,min(14,sizeof(BITMAPFILEHEADER)),1);	67	hFile->Write(&hdr,minimum(14,sizeof(BITMAPFILEHEADER)),1);
68	//copy attributes	68	//copy attributes
69	memcpy(pDib,&head,sizeof(BITMAPINFOHEADER));	69	memcpy(pDib,&head,sizeof(BITMAPINFOHEADER));
70	bihtoh((BITMAPINFOHEADER*)pDib);	70	bihtoh((BITMAPINFOHEADER*)pDib);
Lines 86-92 bool CxImageBMP::Decode(CxFile * hFile) Link Here
86	BITMAPFILEHEADER bf;	86	BITMAPFILEHEADER bf;
87	DWORD off = hFile->Tell(); //<CSC>	87	DWORD off = hFile->Tell(); //<CSC>
88	cx_try {	88	cx_try {
89	if (hFile->Read(&bf,min(14,sizeof(bf)),1)==0) cx_throw("Not a BMP");	89	if (hFile->Read(&bf,minimum(14,sizeof(bf)),1)==0) cx_throw("Not a BMP");
90		90
91	bf.bfSize = my_ntohl(bf.bfSize);	91	bf.bfSize = my_ntohl(bf.bfSize);
92	bf.bfOffBits = my_ntohl(bf.bfOffBits);	92	bf.bfOffBits = my_ntohl(bf.bfOffBits);

Lines 26-33 void CxImage::OverflowCoordinates(long &x, long &y, OverflowMethod const ofMetho Link Here

(-)a/lib/cximage-6.0/CxImage/ximaint.cpp (-4 / +4 lines)
26	switch (ofMethod) {	26	switch (ofMethod) {
27	case OM_REPEAT:	27	case OM_REPEAT:
28	//clip coordinates	28	//clip coordinates
29	x=max(x,0); x=min(x, head.biWidth-1);	29	x=maximum(x,0); x=minimum(x, head.biWidth-1);
30	y=max(y,0); y=min(y, head.biHeight-1);	30	y=maximum(y,0); y=minimum(y, head.biHeight-1);
31	break;	31	break;
32	case OM_WRAP:	32	case OM_WRAP:
33	//wrap coordinates	33	//wrap coordinates
Lines 59-66 void CxImage::OverflowCoordinates(float &x, float &y, OverflowMethod const ofMet Link Here
59	switch (ofMethod) {	59	switch (ofMethod) {
60	case OM_REPEAT:	60	case OM_REPEAT:
61	//clip coordinates	61	//clip coordinates
62	x=max(x,0); x=min(x, head.biWidth-1);	62	x=maximum(x,0); x=minimum(x, head.biWidth-1);
63	y=max(y,0); y=min(y, head.biHeight-1);	63	y=maximum(y,0); y=minimum(y, head.biHeight-1);
64	break;	64	break;
65	case OM_WRAP:	65	case OM_WRAP:
66	//wrap coordinates	66	//wrap coordinates

Lines 398-405 void CxImage::RGBtoBGR(BYTE *buffer, int length) Link Here

(-)a/lib/cximage-6.0/CxImage/ximapal.cpp (-7 / +7 lines)
398	{	398	{
399	if (buffer && (head.biClrUsed==0)){	399	if (buffer && (head.biClrUsed==0)){
400	BYTE temp;	400	BYTE temp;
401	length = min(length,(int)info.dwEffWidth);	401	length = minimum(length,(int)info.dwEffWidth);
402	length = min(length,(int)(3*head.biWidth));	402	length = minimum(length,(int)(3*head.biWidth));
403	for (int i=0;i<length;i+=3){	403	for (int i=0;i<length;i+=3){
404	temp = buffer[i]; buffer[i] = buffer[i+2]; buffer[i+2] = temp;	404	temp = buffer[i]; buffer[i] = buffer[i+2]; buffer[i+2] = temp;
405	}	405	}
Lines 444-450 void CxImage::SetPalette(DWORD n, BYTE r, BYTE g, BYTE *b) Link Here
444	if (!g) g = r;	444	if (!g) g = r;
445	if (!b) b = g;	445	if (!b) b = g;
446	RGBQUAD* ppal=GetPalette();	446	RGBQUAD* ppal=GetPalette();
447	DWORD m=min(n,head.biClrUsed);	447	DWORD m=minimum(n,head.biClrUsed);
448	for (DWORD i=0; i<m;i++){	448	for (DWORD i=0; i<m;i++){
449	ppal[i].rgbRed=r[i];	449	ppal[i].rgbRed=r[i];
450	ppal[i].rgbGreen=g[i];	450	ppal[i].rgbGreen=g[i];
Lines 457-463 void CxImage::SetPalette(rgb_color *rgb,DWORD nColors) Link Here
457	{	457	{
458	if ((!rgb)\|\|(pDib==NULL)\|\|(head.biClrUsed==0)) return;	458	if ((!rgb)\|\|(pDib==NULL)\|\|(head.biClrUsed==0)) return;
459	RGBQUAD* ppal=GetPalette();	459	RGBQUAD* ppal=GetPalette();
460	DWORD m=min(nColors,head.biClrUsed);	460	DWORD m=minimum(nColors,head.biClrUsed);
461	for (DWORD i=0; i<m;i++){	461	for (DWORD i=0; i<m;i++){
462	ppal[i].rgbRed=rgb[i].r;	462	ppal[i].rgbRed=rgb[i].r;
463	ppal[i].rgbGreen=rgb[i].g;	463	ppal[i].rgbGreen=rgb[i].g;
Lines 469-475 void CxImage::SetPalette(rgb_color *rgb,DWORD nColors) Link Here
469	void CxImage::SetPalette(RGBQUAD* pPal,DWORD nColors)	469	void CxImage::SetPalette(RGBQUAD* pPal,DWORD nColors)
470	{	470	{
471	if ((pPal==NULL)\|\|(pDib==NULL)\|\|(head.biClrUsed==0)) return;	471	if ((pPal==NULL)\|\|(pDib==NULL)\|\|(head.biClrUsed==0)) return;
472	memcpy(GetPalette(),pPal,min(GetPaletteSize(),nColors*sizeof(RGBQUAD)));	472	memcpy(GetPalette(),pPal,minimum(GetPaletteSize(),nColors*sizeof(RGBQUAD)));
473	info.last_c_isvalid = false;	473	info.last_c_isvalid = false;
474	}	474	}
475	////////////////////////////////////////////////////////////////////////////////	475	////////////////////////////////////////////////////////////////////////////////
Lines 654-663 void CxImage::SetClrImportant(DWORD ncolors) Link Here
654		654
655	switch(head.biBitCount){	655	switch(head.biBitCount){
656	case 1:	656	case 1:
657	head.biClrImportant = min(ncolors,2);	657	head.biClrImportant = minimum(ncolors,2);
658	break;	658	break;
659	case 4:	659	case 4:
660	head.biClrImportant = min(ncolors,16);	660	head.biClrImportant = minimum(ncolors,16);
661	break;	661	break;
662	case 8:	662	case 8:
663	head.biClrImportant = ncolors;	663	head.biClrImportant = ncolors;

Lines 113-127 bool CxImage::SelectionAddRect(RECT r, BYTE level) Link Here

(-)a/lib/cximage-6.0/CxImage/ximasel.cpp (-25 / +25 lines)
113	if (r.left<r.right) {r2.left=r.left; r2.right=r.right; } else {r2.left=r.right ; r2.right=r.left; }	113	if (r.left<r.right) {r2.left=r.left; r2.right=r.right; } else {r2.left=r.right ; r2.right=r.left; }
114	if (r.bottom<r.top) {r2.bottom=r.bottom; r2.top=r.top; } else {r2.bottom=r.top ; r2.top=r.bottom; }	114	if (r.bottom<r.top) {r2.bottom=r.bottom; r2.top=r.top; } else {r2.bottom=r.top ; r2.top=r.bottom; }
115		115
116	if (info.rSelectionBox.top <= r2.top) info.rSelectionBox.top = max(0L,min(head.biHeight,r2.top+1));	116	if (info.rSelectionBox.top <= r2.top) info.rSelectionBox.top = maximum(0L,minimum(head.biHeight,r2.top+1));
117	if (info.rSelectionBox.left > r2.left) info.rSelectionBox.left = max(0L,min(head.biWidth,r2.left));	117	if (info.rSelectionBox.left > r2.left) info.rSelectionBox.left = maximum(0L,minimum(head.biWidth,r2.left));
118	if (info.rSelectionBox.right <= r2.right) info.rSelectionBox.right = max(0L,min(head.biWidth,r2.right+1));	118	if (info.rSelectionBox.right <= r2.right) info.rSelectionBox.right = maximum(0L,minimum(head.biWidth,r2.right+1));
119	if (info.rSelectionBox.bottom > r2.bottom) info.rSelectionBox.bottom = max(0L,min(head.biHeight,r2.bottom));	119	if (info.rSelectionBox.bottom > r2.bottom) info.rSelectionBox.bottom = maximum(0L,minimum(head.biHeight,r2.bottom));
120		120
121	long ymin = max(0L,min(head.biHeight,r2.bottom));	121	long ymin = maximum(0L,minimum(head.biHeight,r2.bottom));
122	long ymax = max(0L,min(head.biHeight,r2.top+1));	122	long ymax = maximum(0L,minimum(head.biHeight,r2.top+1));
123	long xmin = max(0L,min(head.biWidth,r2.left));	123	long xmin = maximum(0L,minimum(head.biWidth,r2.left));
124	long xmax = max(0L,min(head.biWidth,r2.right+1));	124	long xmax = maximum(0L,minimum(head.biWidth,r2.right+1));
125		125
126	for (long y=ymin; y<ymax; y++)	126	for (long y=ymin; y<ymax; y++)
127	memset(pSelection + xmin + y * head.biWidth, level, xmax-xmin);	127	memset(pSelection + xmin + y * head.biWidth, level, xmax-xmin);
Lines 144-161 bool CxImage::SelectionAddEllipse(RECT r, BYTE level) Link Here
144	long xcenter = (r.right + r.left)/2;	144	long xcenter = (r.right + r.left)/2;
145	long ycenter = (r.top + r.bottom)/2;	145	long ycenter = (r.top + r.bottom)/2;
146		146
147	if (info.rSelectionBox.left > (xcenter - xradius)) info.rSelectionBox.left = max(0L,min(head.biWidth,(xcenter - xradius)));	147	if (info.rSelectionBox.left > (xcenter - xradius)) info.rSelectionBox.left = maximum(0L,minimum(head.biWidth,(xcenter - xradius)));
148	if (info.rSelectionBox.right <= (xcenter + xradius)) info.rSelectionBox.right = max(0L,min(head.biWidth,(xcenter + xradius + 1)));	148	if (info.rSelectionBox.right <= (xcenter + xradius)) info.rSelectionBox.right = maximum(0L,minimum(head.biWidth,(xcenter + xradius + 1)));
149	if (info.rSelectionBox.bottom > (ycenter - yradius)) info.rSelectionBox.bottom = max(0L,min(head.biHeight,(ycenter - yradius)));	149	if (info.rSelectionBox.bottom > (ycenter - yradius)) info.rSelectionBox.bottom = maximum(0L,minimum(head.biHeight,(ycenter - yradius)));
150	if (info.rSelectionBox.top <= (ycenter + yradius)) info.rSelectionBox.top = max(0L,min(head.biHeight,(ycenter + yradius + 1)));	150	if (info.rSelectionBox.top <= (ycenter + yradius)) info.rSelectionBox.top = maximum(0L,minimum(head.biHeight,(ycenter + yradius + 1)));
151		151
152	long xmin = max(0L,min(head.biWidth,xcenter - xradius));	152	long xmin = maximum(0L,minimum(head.biWidth,xcenter - xradius));
153	long xmax = max(0L,min(head.biWidth,xcenter + xradius + 1));	153	long xmax = maximum(0L,minimum(head.biWidth,xcenter + xradius + 1));
154	long ymin = max(0L,min(head.biHeight,ycenter - yradius));	154	long ymin = maximum(0L,minimum(head.biHeight,ycenter - yradius));
155	long ymax = max(0L,min(head.biHeight,ycenter + yradius + 1));	155	long ymax = maximum(0L,minimum(head.biHeight,ycenter + yradius + 1));
156		156
157	long y,yo;	157	long y,yo;
158	for (y=ymin; y<min(ycenter,ymax); y++){	158	for (y=ymin; y<minimum(ycenter,ymax); y++){
159	for (long x=xmin; x<xmax; x++){	159	for (long x=xmin; x<xmax; x++){
160	yo = (long)(ycenter - yradius * sqrt(1-pow((float)(x - xcenter)/(float)xradius,2)));	160	yo = (long)(ycenter - yradius * sqrt(1-pow((float)(x - xcenter)/(float)xradius,2)));
161	if (yo<y) pSelection[x + y * head.biWidth] = level;	161	if (yo<y) pSelection[x + y * head.biWidth] = level;
Lines 268-277 bool CxImage::SelectionAddPolygon(POINT *points, long npoints, BYTE level) Link Here
268	RECT r2;	268	RECT r2;
269	if (current->x < next->x) {r2.left=current->x; r2.right=next->x; } else {r2.left=next->x ; r2.right=current->x; }	269	if (current->x < next->x) {r2.left=current->x; r2.right=next->x; } else {r2.left=next->x ; r2.right=current->x; }
270	if (current->y < next->y) {r2.bottom=current->y; r2.top=next->y; } else {r2.bottom=next->y ; r2.top=current->y; }	270	if (current->y < next->y) {r2.bottom=current->y; r2.top=next->y; } else {r2.bottom=next->y ; r2.top=current->y; }
271	if (localbox.top < r2.top) localbox.top = max(0L,min(head.biHeight-1,r2.top+1));	271	if (localbox.top < r2.top) localbox.top = maximum(0L,minimum(head.biHeight-1,r2.top+1));
272	if (localbox.left > r2.left) localbox.left = max(0L,min(head.biWidth-1,r2.left-1));	272	if (localbox.left > r2.left) localbox.left = maximum(0L,minimum(head.biWidth-1,r2.left-1));
273	if (localbox.right < r2.right) localbox.right = max(0L,min(head.biWidth-1,r2.right+1));	273	if (localbox.right < r2.right) localbox.right = maximum(0L,minimum(head.biWidth-1,r2.right+1));
274	if (localbox.bottom > r2.bottom) localbox.bottom = max(0L,min(head.biHeight-1,r2.bottom-1));	274	if (localbox.bottom > r2.bottom) localbox.bottom = maximum(0L,minimum(head.biHeight-1,r2.bottom-1));
275		275
276	i++;	276	i++;
277	}	277	}
Lines 385-394 bool CxImage::SelectionAddPolygon(POINT *points, long npoints, BYTE level) Link Here
385	for (x=localbox.left; x<=localbox.right; x++)	385	for (x=localbox.left; x<=localbox.right; x++)
386	if (plocal[x + yoffset]!=1) pSelection[x + yoffset]=level;	386	if (plocal[x + yoffset]!=1) pSelection[x + yoffset]=level;
387	}	387	}
388	if (info.rSelectionBox.top <= localbox.top) info.rSelectionBox.top = min(head.biHeight,localbox.top + 1);	388	if (info.rSelectionBox.top <= localbox.top) info.rSelectionBox.top = minimum(head.biHeight,localbox.top + 1);
389	if (info.rSelectionBox.left > localbox.left) info.rSelectionBox.left = min(head.biWidth,localbox.left);	389	if (info.rSelectionBox.left > localbox.left) info.rSelectionBox.left = minimum(head.biWidth,localbox.left);
390	if (info.rSelectionBox.right <= localbox.right) info.rSelectionBox.right = min(head.biWidth,localbox.right + 1);	390	if (info.rSelectionBox.right <= localbox.right) info.rSelectionBox.right = minimum(head.biWidth,localbox.right + 1);
391	if (info.rSelectionBox.bottom > localbox.bottom) info.rSelectionBox.bottom = min(head.biHeight,localbox.bottom);	391	if (info.rSelectionBox.bottom > localbox.bottom) info.rSelectionBox.bottom = minimum(head.biHeight,localbox.bottom);
392		392
393	free(plocal);	393	free(plocal);
394	free(pix);	394	free(pix);