pvr_tex: Remove unused variables map[] and pal[] and #if 0 sectioned code

Author: andressbarajas

utils/pvrtex/dither.cpp

@@ -7,237 +7,8 @@
 #include <vector>
 #include <map>       /* For associative container, std::map<> */
 
-////////////////////////////////////////////////////
-#if 0
-#include <utility> // for std::pair
-#include "alloc/FSBAllocator.hh"
-
-/* kd-tree implementation translated to C++
- * from java implementation in VideoMosaic
- * at http://www.intelegance.net/video/videomosaic.shtml.
- */
-
-template<typename V, unsigned K = 3>
-class KDTree {
-public:
-	struct KDPoint {
-		double coord[K];
-
-		KDPoint() { }
-
-		KDPoint(double a,double b,double c) {
-			coord[0] = a;
-			coord[1] = b;
-			coord[2] = c;
-		}
-
-		KDPoint(double v[K]) {
-			for(unsigned n=0; n<K; ++n)
-				coord[n] = v[n];
-		}
-
-		bool operator==(const KDPoint& b) const {
-			for(unsigned n=0; n<K; ++n)
-				if(coord[n] != b.coord[n]) return false;
-			return true;
-		}
-		double sqrdist(const KDPoint& b) const {
-			double result = 0;
-			for(unsigned n=0; n<K; ++n) {
-				double diff = coord[n] - b.coord[n];
-				result += diff*diff;
-			}
-			return result;
-		}
-	};
-private:
-	struct KDRect {
-		KDPoint min, max;
-
-		KDPoint bound(const KDPoint& t) const {
-			KDPoint p;
-			for(unsigned i=0; i<K; ++i)
-				if(t.coord[i] <= min.coord[i])
-					p.coord[i] = min.coord[i];
-				else if(t.coord[i] >= max.coord[i])
-					p.coord[i] = max.coord[i];
-				else
-					p.coord[i] = t.coord[i];
-			return p;
-		}
-		void MakeInfinite() {
-			for(unsigned i=0; i<K; ++i) {
-				min.coord[i] = -1e99;
-				max.coord[i] =  1e99;
-			}
-		}
-	};
-
-	struct KDNode {
-		KDPoint k;
-		V       v;
-		KDNode  *left, *right;
-	public:
-		KDNode() : k(),v(),left(0),right(0) { }
-		KDNode(const KDPoint& kk, const V& vv) : k(kk), v(vv), left(0), right(0) { }
-
-		virtual ~KDNode() {
-			delete (left);
-			delete (right);
-		}
-
-		static KDNode* ins( const KDPoint& key, const V& val,
-				    KDNode*& t, int lev) {
-			if(!t)
-				return (t = new KDNode(key, val));
-			else if(key == t->k)
-				return 0; /* key duplicate */
-			else if(key.coord[lev] > t->k.coord[lev])
-				return ins(key, val, t->right, (lev+1)%K);
-			else
-				return ins(key, val, t->left,  (lev+1)%K);
-		}
-		struct Nearest {
-			const KDNode* kd;
-			double        dist_sqd;
-		};
-		// Method Nearest Neighbor from Andrew Moore's thesis. Numbered
-		// comments are direct quotes from there. Step "SDL" is added to
-		// make the algorithm work correctly.
-		static void nnbr(const KDNode* kd, const KDPoint& target,
-				 KDRect& hr, // in-param and temporary; not an out-param.
-				 int lev,
-				 Nearest& nearest) {
-			// 1. if kd is empty then set dist-sqd to infinity and exit.
-			if (!kd) return;
-
-			// 2. s := split field of kd
-			int s = lev % K;
-
-			// 3. pivot := dom-elt field of kd
-			const KDPoint& pivot = kd->k;
-			double pivot_to_target = pivot.sqrdist(target);
-
-			// 4. Cut hr into to sub-hyperrectangles left-hr and right-hr.
-			//    The cut plane is through pivot and perpendicular to the s
-			//    dimension.
-			KDRect& left_hr = hr; // optimize by not cloning
-			KDRect right_hr = hr;
-			left_hr.max.coord[s]  = pivot.coord[s];
-			right_hr.min.coord[s] = pivot.coord[s];
-
-			// 5. target-in-left := target_s <= pivot_s
-			bool target_in_left = target.coord[s] < pivot.coord[s];
-
-			const KDNode* nearer_kd;
-			const KDNode* further_kd;
-			KDRect nearer_hr;
-			KDRect further_hr;
-
-			// 6. if target-in-left then nearer is left, further is right
-			if (target_in_left) {
-				nearer_kd = kd->left;
-				nearer_hr = left_hr;
-				further_kd = kd->right;
-				further_hr = right_hr;
-			}
-			// 7. if not target-in-left then nearer is right, further is left
-			else {
-				nearer_kd = kd->right;
-				nearer_hr = right_hr;
-				further_kd = kd->left;
-				further_hr = left_hr;
-			}
-
-			// 8. Recursively call Nearest Neighbor with parameters
-			//    (nearer-kd, target, nearer-hr, max-dist-sqd), storing the
-			//    results in nearest and dist-sqd
-			nnbr(nearer_kd, target, nearer_hr, lev + 1, nearest);
-
-			// 10. A nearer point could only lie in further-kd if there were some
-			//     part of further-hr within distance sqrt(max-dist-sqd) of
-			//     target.  If this is the case then
-			const KDPoint closest = further_hr.bound(target);
-			if (closest.sqrdist(target) < nearest.dist_sqd) {
-				// 10.1 if (pivot-target)^2 < dist-sqd then
-				if (pivot_to_target < nearest.dist_sqd) {
-					// 10.1.1 nearest := (pivot, range-elt field of kd)
-					nearest.kd = kd;
-					// 10.1.2 dist-sqd = (pivot-target)^2
-					nearest.dist_sqd = pivot_to_target;
-				}
-
-				// 10.2 Recursively call Nearest Neighbor with parameters
-				//      (further-kd, target, further-hr, max-dist_sqd)
-				nnbr(further_kd, target, further_hr, lev + 1, nearest);
-			}
-			// SDL: otherwise, current point is nearest
-			else if (pivot_to_target < nearest.dist_sqd) {
-				nearest.kd       = kd;
-				nearest.dist_sqd = pivot_to_target;
-			}
-		}
-	private:
-		void operator=(const KDNode&);
-	public:
-		KDNode(const KDNode& b)
-			: k(b.k), v(b.v),
-			  left( b.left ? new KDNode(*b.left) : 0),
-			  right( b.right ? new KDNode(*b.right) : 0 ) { }
-	};
-private:
-	KDNode* m_root;
-public:
-	KDTree() : m_root(0) { }
-	virtual ~KDTree() {
-		delete (m_root);
-	}
-
-	bool insert(const KDPoint& key, const V& val) {
-		return KDNode::ins(key, val, m_root, 0);
-	}
-
-	const std::pair<V,double> nearest(const KDPoint& key) const {
-		KDRect hr;
-		hr.MakeInfinite();
-
-		typename KDNode::Nearest nn;
-		nn.kd       = 0;
-		nn.dist_sqd = 1e99;
-		KDNode::nnbr(m_root, key, hr, 0, nn);
-		if(!nn.kd) return std::pair<V,double> ( V(), 1e99 );
-		return std::pair<V,double> ( nn.kd->v, nn.dist_sqd);
-	}
-public:
-	KDTree& operator=(const KDTree&b) {
-		if(this != &b) {
-			if(m_root) delete (m_root);
-			m_root = b.m_root ? new KDNode(*b.m_root) : 0;
-			m_count = b.m_count;
-		}
-		return *this;
-	}
-	KDTree(const KDTree& b)
-		: m_root( b.m_root ? new KDNode(*b.m_root) : 0 ),
-		  m_count( b.m_count ) { }
-};
-#endif
-////////////////////////////////////////////////////
-
 #define COMPARE_RGB 1
 
-/* 8x8 threshold map */
-static const unsigned char map[8*8] = {
-	0,48,12,60, 3,51,15,63,
-	32,16,44,28,35,19,47,31,
-	8,56, 4,52,11,59, 7,55,
-	40,24,36,20,43,27,39,23,
-	2,50,14,62, 1,49,13,61,
-	34,18,46,30,33,17,45,29,
-	10,58, 6,54, 9,57, 5,53,
-	42,26,38,22,41,25,37,21
-};
-
 static const double Gamma = 2.2; // Gamma correction we use.
 
 double GammaCorrect(double v)   {
@@ -377,13 +148,8 @@ double ColorCompare(int r1,int g1,int b1, int r2,int g2,int b2) {
 	       + lumadiff*lumadiff;
 }
 
-
 /* Palette */
 static const unsigned palettesize = 16;
-static const unsigned pal[palettesize] = {
-	0x080000,0x201A0B,0x432817,0x492910, 0x234309,0x5D4F1E,0x9C6B20,0xA9220F,
-	0x2B347C,0x2B7409,0xD0CA40,0xE8A077, 0x6A94AB,0xD5C4B3,0xFCE76E,0xFCFAE2
-};
 
 /* Luminance for each palette entry, to be initialized as soon as the program begins */
 static unsigned luma[palettesize];
@@ -457,37 +223,4 @@ MixingPlan DeviseBestMixingPlan(unsigned color, size_t limit) {
 	std::sort(result.begin(), result.end(), PaletteCompareLuma);
 	return result;
 }
-#if 0
-int main(int argc, char**argv) {
-	FILE* fp = fopen(argv[1], "rb");
-	gdImagePtr srcim = gdImageCreateFromPng(fp);
-	fclose(fp);
 
-	unsigned w = gdImageSX(srcim), h = gdImageSY(srcim);
-	gdImagePtr im = gdImageCreate(w, h);
-	for(unsigned c=0; c<palettesize; ++c) {
-		unsigned r = pal[c]>>16, g = (pal[c]>>8) & 0xFF, b = pal[c] & 0xFF;
-		gdImageColorAllocate(im, r,g,b);
-		luma[c] = r*299 + g*587 + b*114;
-		meta[c].Set(pal[c]);
-		pal_g[c][0] = GammaCorrect(r/255.0);
-		pal_g[c][1] = GammaCorrect(g/255.0);
-		pal_g[c][2] = GammaCorrect(b/255.0);
-	}
-	#pragma omp parallel for
-	for(unsigned y=0; y<h; ++y)
-		for(unsigned x=0; x<w; ++x) {
-			unsigned color = gdImageGetTrueColorPixel(srcim, x, y);
-			unsigned map_value = map[(x & 7) + ((y & 7) << 3)];
-			MixingPlan plan = DeviseBestMixingPlan(color, 16);
-			map_value = map_value * plan.size() / 64;
-			gdImageSetPixel(im, x,y, plan[ map_value ]);
-		}
-	fp = fopen(argv[2], "wb");
-	gdImagePng(im, fp);
-	fclose(fp);
-	gdImageDestroy(im);
-	gdImageDestroy(srcim);
-	return 0;
-}
-#endif