plugins folders renaming

git-svn-id: http://svn.miranda-ng.org/main/trunk@61 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c

1 files changed, 0 insertions, 225 deletions

diff --git a/plugins/freeimage/Source/Quantizers.h b/plugins/freeimage/Source/Quantizers.h
deleted file mode 100644
index bc84f77724..0000000000
--- a/plugins/freeimage/Source/Quantizers.h
+++ /dev/null
@@ -1,225 +0,0 @@
-// =============================================================

-// Quantizer objects and functions

-//

-// Design and implementation by:

-// - Hervé Drolon <drolon@infonie.fr>

-//

-// This file is part of FreeImage 3

-//

-// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY

-// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES

-// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE

-// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED

-// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT

-// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY

-// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL

-// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER

-// THIS DISCLAIMER.

-//

-// Use at your own risk!

-// =============================================================

-

-// 

-////////////////////////////////////////////////////////////////

-

-#include "FreeImage.h"

-

-////////////////////////////////////////////////////////////////

-

-/**

-  Xiaolin Wu color quantization algorithm

-*/

-class WuQuantizer

-{

-public:

-

-typedef struct tagBox {

-    int r0;			 // min value, exclusive

-    int r1;			 // max value, inclusive

-    int g0;  

-    int g1;  

-    int b0;  

-    int b1;

-    int vol;

-} Box;

-

-protected:

-    float *gm2;

-	LONG *wt, *mr, *mg, *mb;

-	WORD *Qadd;

-

-	// DIB data

-	unsigned width, height;

-	unsigned pitch;

-	FIBITMAP *m_dib;

-

-protected:

-    void Hist3D(LONG *vwt, LONG *vmr, LONG *vmg, LONG *vmb, float *m2, int ReserveSize, RGBQUAD *ReservePalette);

-	void M3D(LONG *vwt, LONG *vmr, LONG *vmg, LONG *vmb, float *m2);

-	LONG Vol(Box *cube, LONG *mmt);

-	LONG Bottom(Box *cube, BYTE dir, LONG *mmt);

-	LONG Top(Box *cube, BYTE dir, int pos, LONG *mmt);

-	float Var(Box *cube);

-	float Maximize(Box *cube, BYTE dir, int first, int last , int *cut,

-				   LONG whole_r, LONG whole_g, LONG whole_b, LONG whole_w);

-	bool Cut(Box *set1, Box *set2);

-	void Mark(Box *cube, int label, BYTE *tag);

-

-public:

-	// Constructor - Input parameter: DIB 24-bit to be quantized

-    WuQuantizer(FIBITMAP *dib);

-	// Destructor

-	~WuQuantizer();

-	// Quantizer - Return value: quantized 8-bit (color palette) DIB

-	FIBITMAP* Quantize(int PaletteSize, int ReserveSize, RGBQUAD *ReservePalette);

-};

-

-

-/**

-  NEUQUANT Neural-Net quantization algorithm by Anthony Dekker

-*/

-

-// ----------------------------------------------------------------

-// Constant definitions

-// ----------------------------------------------------------------

-

-/** number of colours used: 

-	for 256 colours, fixed arrays need 8kb, plus space for the image

-*/

-//static const int netsize = 256;

-

-/**@name network definitions */

-//@{

-//static const int maxnetpos = (netsize - 1);

-/// bias for colour values

-static const int netbiasshift = 4;

-/// no. of learning cycles

-static const int ncycles = 100;

-//@}

-

-/**@name defs for freq and bias */

-//@{

-/// bias for fractions

-static const int intbiasshift = 16;

-static const int intbias = (((int)1) << intbiasshift);

-/// gamma = 1024

-static const int gammashift = 10;

-// static const int gamma = (((int)1) << gammashift);

-/// beta = 1 / 1024

-static const int betashift = 10;

-static const int beta = (intbias >> betashift);

-static const int betagamma = (intbias << (gammashift-betashift));

-//@}

-

-/**@name defs for decreasing radius factor */

-//@{

-/// for 256 cols, radius starts

-//static const int initrad = (netsize >> 3);

-/// at 32.0 biased by 6 bits

-static const int radiusbiasshift = 6;

-static const int radiusbias = (((int)1) << radiusbiasshift);

-/// and decreases by a 

-//static const int initradius	= (initrad * radiusbias);

-// factor of 1/30 each cycle

-static const int radiusdec = 30;

-//@}

-

-/**@name defs for decreasing alpha factor */

-//@{

-/// alpha starts at 1.0

-static const int alphabiasshift = 10;

-static const int initalpha = (((int)1) << alphabiasshift);

-//@}

-

-/**@name radbias and alpharadbias used for radpower calculation */

-//@{

-static const int radbiasshift = 8;

-static const int radbias = (((int)1) << radbiasshift);

-static const int alpharadbshift = (alphabiasshift+radbiasshift);

-static const int alpharadbias = (((int)1) << alpharadbshift);	

-//@}

-

-class NNQuantizer

-{

-protected:

-	/**@name image parameters */

-	//@{

-	/// pointer to input dib

-	FIBITMAP *dib_ptr;

-	/// image width

-	int img_width;

-	/// image height

-	int img_height;

-	/// image line length

-	int img_line;

-	//@}

-

-	/**@name network parameters */

-	//@{

-

-	int netsize, maxnetpos, initrad, initradius;

-

-	/// BGRc

-	typedef int pixel[4];

-	/// the network itself

-	pixel *network;

-

-	/// for network lookup - really 256

-	int netindex[256];

-

-	/// bias array for learning

-	int *bias;

-	/// freq array for learning

-	int *freq;

-	/// radpower for precomputation

-	int *radpower;

-	//@}

-

-protected:

-	/// Initialise network in range (0,0,0) to (255,255,255) and set parameters

-	void initnet();	

-

-	/// Unbias network to give byte values 0..255 and record position i to prepare for sort

-	void unbiasnet();

-

-	/// Insertion sort of network and building of netindex[0..255] (to do after unbias)

-	void inxbuild();

-

-	/// Search for BGR values 0..255 (after net is unbiased) and return colour index

-	int inxsearch(int b, int g, int r);

-

-	/// Search for biased BGR values

-	int contest(int b, int g, int r);

-	

-	/// Move neuron i towards biased (b,g,r) by factor alpha

-	void altersingle(int alpha, int i, int b, int g, int r);

-

-	/// Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in radpower[|i-j|]

-	void alterneigh(int rad, int i, int b, int g, int r);

-

-	/** Main Learning Loop

-	@param sampling_factor sampling factor in [1..30]

-	*/

-	void learn(int sampling_factor);

-

-	/// Get a pixel sample at position pos. Handle 4-byte boundary alignment.

-	void getSample(long pos, int *b, int *g, int *r);

-

-

-public:

-	/// Constructor

-	NNQuantizer(int PaletteSize);

-

-	/// Destructor

-	~NNQuantizer();

-

-	/** Quantizer

-	@param dib input 24-bit dib to be quantized

-	@param sampling a sampling factor in range 1..30. 

-	1 => slower (but better), 30 => faster. Default value is 1

-	@return returns the quantized 8-bit (color palette) DIB

-	*/

-	FIBITMAP* Quantize(FIBITMAP *dib, int ReserveSize, RGBQUAD *ReservePalette, int sampling = 1);

-

-};

-