Commit: 67e551fdb121c01fa39e8f7572d283f740f49a5a - color_quantizer (git)

減色プログラム

Commit MetaInfo

• Revision: 67e551fdb121c01fa39e8f7572d283f740f49a5a (tree)
• Zeit: 2011-05-17 01:57:56
• Autor: berupon <berupon@gmai...>
• Commiter: berupon

Log Message

型をdoubleからfloatに変更できるところを変更。

Ändern Zusammenfassung

• modified: main.cpp
• modified: quantize.cpp
• modified: quantize.h

Diff

--- a/main.cpp
+++ b/main.cpp
@@ -23,15 +23,15 @@ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
-
-
-#include "stdafx.h"
-
-#include "Color4f.h"
-#include "Array.h"
-
-typedef Array2D<Color4f> Image4f;
-
+
+
+#include "stdafx.h"
+
+#include "Color4f.h"
+#include "Array.h"
+
+typedef Array2D<Color4f> Image4f;
+
 #include <algorithm>
 #include <math.h>
 #include <stdio.h>
@@ -40,91 +40,91 @@ typedef Array2D<Color4f> Image4f;
 #include <deque>
 #include <limits>
 #include <iostream>
-
-#include "ReadImage/ReadImage.h"
-#include "ReadImage/File.h"
-
-#include "quantize.h"
-
-// http://proglab.aki.gs/mediaproc/colors.html
-
-int _tmain(int argc, _TCHAR* argv[])
-{
-	if (argc < 1+3 || argc > 1+5) {
-		puts("Usage: color_quantizer <source image.bmp> <output image.raw> <desired palette size> [dithering level] [filter size (1/3/5)]\n");
-		return -1;
-	}
-	
-	int num_colors = _ttoi(argv[3]);
+
+#include "ReadImage/ReadImage.h"
+#include "ReadImage/File.h"
+
+#include "quantize.h"
+
+// http://proglab.aki.gs/mediaproc/colors.html
+
+int _tmain(int argc, _TCHAR* argv[])
+{
+	if (argc < 1+3 || argc > 1+5) {
+		puts("Usage: color_quantizer <source image.bmp> <output image.raw> <desired palette size> [dithering level] [filter size (1/3/5)]\n");
+		return -1;
+	}
+	
+	int num_colors = _ttoi(argv[3]);
 	if (num_colors <= 1 || num_colors > 256) {
 		printf("Number of colors must be at least 2 and no more than 256.\n");
 		return -1;
 	}
-	
-	srand(time(NULL));
-	
-	ImageInfo imageInfo;
-	FILE* f = _tfopen(argv[1], _T("rb"));
-	File file(f);
-	if (!ReadImageInfo(file, imageInfo)) {
-		puts("failed to open image\n");
-		return 0;
-	}
-	if (
-		imageInfo.bitsPerSample != 8
-		|| (imageInfo.samplesPerPixel != 3 && imageInfo.samplesPerPixel != 4)
-	) {
-		puts("unsupported image file format.\n");
-		return 0;
-	}
-	size_t lineBytes = imageInfo.samplesPerPixel * imageInfo.width;
-	if (lineBytes % 4) {
-		lineBytes += 4 - (lineBytes % 4);
-	}
-	std::vector<uint8_t> buff(lineBytes * imageInfo.height);
-	ReadImageData(file, &buff[0], lineBytes, 0);
-	fclose(f);
-	uint8_t* p = &buff[0];
-	
-	size_t width = imageInfo.width;
-	size_t height = imageInfo.height;
-	Image4f image(width, height);
-	Color4f* pLine = image.pBuff_;
-	uint8_t* pSrcLine = p;
-	for (size_t y=0; y<height; ++y) {
-		for (size_t x=0; x<width; ++x) {
-			float r = pSrcLine[x*3+0] / 255.0f;
-			float g = pSrcLine[x*3+1] / 255.0f;
-			float b = pSrcLine[x*3+2] / 255.0f;
-			pLine[x] = Color4f(r,g,b,0.0f);
-		}
-		pLine += width;
-		pSrcLine += lineBytes;
-	}
-	Color4f buff_filter1_weights[1*1];
-	Color4f buff_filter3_weights[3*3];
-	Color4f buff_filter5_weights[5*5];
-
-	Image4f filter1_weights(1, 1, buff_filter1_weights);
-	Image4f filter3_weights(3, 3, buff_filter3_weights);
-	Image4f filter5_weights(5, 5, buff_filter5_weights);
-	std::vector<uint8_t> buff_quantized(width * height);
-	Array2D<uint8_t> quantized_image(width, height, &buff_quantized[0]);
-	Color4f palette[256];
-	
-	filter1_weights[0][0] = Color4f(1.0f, 1.0f, 1.0f, 0.0f);
-	
-	for (size_t i=0; i<num_colors; ++i) {
-		palette[i] = Color4f(
-			((float)rand())/RAND_MAX,
-			((float)rand())/RAND_MAX,
-			((float)rand())/RAND_MAX,
-			0.0f
-			);
-	}
-
-	Array3D<double>* coarse_variables;
-	double dithering_level = 0.09*log((double)image.width_*image.height_) - 0.04*log((double)num_colors) + 0.001;
+	
+	srand(time(NULL));
+	
+	ImageInfo imageInfo;
+	FILE* f = _tfopen(argv[1], _T("rb"));
+	File file(f);
+	if (!ReadImageInfo(file, imageInfo)) {
+		puts("failed to open image\n");
+		return 0;
+	}
+	if (
+		imageInfo.bitsPerSample != 8
+		|| (imageInfo.samplesPerPixel != 3 && imageInfo.samplesPerPixel != 4)
+	) {
+		puts("unsupported image file format.\n");
+		return 0;
+	}
+	size_t lineBytes = imageInfo.samplesPerPixel * imageInfo.width;
+	if (lineBytes % 4) {
+		lineBytes += 4 - (lineBytes % 4);
+	}
+	std::vector<uint8_t> buff(lineBytes * imageInfo.height);
+	ReadImageData(file, &buff[0], lineBytes, 0);
+	fclose(f);
+	uint8_t* p = &buff[0];
+	
+	size_t width = imageInfo.width;
+	size_t height = imageInfo.height;
+	Image4f image(width, height);
+	Color4f* pLine = image.pBuff_;
+	uint8_t* pSrcLine = p;
+	for (size_t y=0; y<height; ++y) {
+		for (size_t x=0; x<width; ++x) {
+			float r = pSrcLine[x*3+0] / 255.0f;
+			float g = pSrcLine[x*3+1] / 255.0f;
+			float b = pSrcLine[x*3+2] / 255.0f;
+			pLine[x] = Color4f(r,g,b,0.0f);
+		}
+		pLine += width;
+		pSrcLine += lineBytes;
+	}
+	Color4f buff_filter1_weights[1*1];
+	Color4f buff_filter3_weights[3*3];
+	Color4f buff_filter5_weights[5*5];
+
+	Image4f filter1_weights(1, 1, buff_filter1_weights);
+	Image4f filter3_weights(3, 3, buff_filter3_weights);
+	Image4f filter5_weights(5, 5, buff_filter5_weights);
+	std::vector<uint8_t> buff_quantized(width * height);
+	Array2D<uint8_t> quantized_image(width, height, &buff_quantized[0]);
+	Color4f palette[256];
+	
+	filter1_weights[0][0] = Color4f(1.0f, 1.0f, 1.0f, 0.0f);
+	
+	for (size_t i=0; i<num_colors; ++i) {
+		palette[i] = Color4f(
+			((float)rand())/RAND_MAX,
+			((float)rand())/RAND_MAX,
+			((float)rand())/RAND_MAX,
+			0.0f
+			);
+	}
+
+	Array3D<float>* coarse_variables;
+	float dithering_level = 0.09*log((float)image.width_*image.height_) - 0.04*log((float)num_colors) + 0.001;
 	if (argc > 1+3) {
 		dithering_level = _ttof(argv[4]); 
 		if (dithering_level <= 0.0) {
@@ -141,11 +141,11 @@ int _tmain(int argc, _TCHAR* argv[])
 		}
 	}
 
-	double stddev = dithering_level;
-	double sum = 0.0;
+	float stddev = dithering_level;
+	float sum = 0.0;
 	for (int i=0; i<3; i++) {
 		for (int j=0; j<3; j++) {
-			double w = exp(-sqrt((double)((i-1)*(i-1) + (j-1)*(j-1)))/(stddev*stddev));
+			float w = exp(-sqrt((float)((i-1)*(i-1) + (j-1)*(j-1)))/(stddev*stddev));
 			filter3_weights[i][j] = Color4f(w,w,w,0);
 			sum += 3 * w;
 		}
@@ -161,7 +161,7 @@ int _tmain(int argc, _TCHAR* argv[])
 	sum = 0.0;
 	for (int i=0; i<5; i++) {
 		for (int j=0; j<5; j++) {
-			double w = exp(-sqrt((double)((i-2)*(i-2) + (j-2)*(j-2)))/(stddev*stddev));
+			float w = exp(-sqrt((float)((i-2)*(i-2) + (j-2)*(j-2)))/(stddev*stddev));
 			filter5_weights[i][j] = Color4f(w,w,w,0);
 			sum += 3 * w;
 		}
@@ -183,8 +183,8 @@ int _tmain(int argc, _TCHAR* argv[])
 		NULL,
 		&filter5_weights
 	};
-	spatial_color_quant(image, *filters[filter_size], quantized_image, palette, num_colors, coarse_variables, 1.0, 0.001, 3, 1);
-	
+	spatial_color_quant(image, *filters[filter_size], quantized_image, palette, num_colors, coarse_variables, 1.0, 0.001, 3, 1);
+	
 	{
 		FILE* out = _tfopen(argv[2], _T("wb"));
 		if (out == NULL) {
@@ -194,15 +194,17 @@ int _tmain(int argc, _TCHAR* argv[])
 		unsigned char c[3] = {0,0,0};
 		for (int y=0; y<height; y++) {
 			for (int x=0; x<width; x++) {
-				c[2] = (unsigned char)(255*palette[quantized_image[y][x]][0]);
-				c[1] = (unsigned char)(255*palette[quantized_image[y][x]][1]);
-				c[0] = (unsigned char)(255*palette[quantized_image[y][x]][2]);
+				const uint8_t idx = quantized_image[y][x];
+				Color4f col = palette[idx];
+				c[2] = (unsigned char)(255*col[0]);
+				c[1] = (unsigned char)(255*col[1]);
+				c[0] = (unsigned char)(255*col[2]);
 				fwrite(c, 3, 1, out);
 			}
 		}
 		fclose(out);
 	}
-
-	return 0;
-}
-
+
+	return 0;
+}
+

--- a/quantize.cpp
+++ b/quantize.cpp
@@ -1,5 +1,5 @@
-#include "stdafx.h"
-
+#include "stdafx.h"
+
 #include <algorithm>
 #include <math.h>
 #include <stdio.h>
@@ -8,14 +8,14 @@
 #include <deque>
 #include <limits>
 #include <iostream>
-
-using namespace std;
-
-#include "Array.h"
-#include "Color4f.h"
-
-typedef Array2D<Color4f> Image4f;
-
+
+using namespace std;
+
+#include "Array.h"
+#include "Color4f.h"
+
+typedef Array2D<Color4f> Image4f;
+
 int compute_max_coarse_level(int width, int height)
 {
 	// We want the coarsest layer to have at most MAX_PIXELS pixels
@@ -29,23 +29,23 @@ int compute_max_coarse_level(int width, int height)
 	return result;
 }
 
-void fill_random(Array3D<double>& a)
+void fill_random(Array3D<float>& a)
 {
 	for (int i=0; i<a.width_; i++) {
 		for (int j=0; j<a.height_; j++) {
 			for (int k=0; k<a.depth_; k++) {
-				a[k][j][i] = ((double)rand())/RAND_MAX;
+				a[k][j][i] = ((float)rand())/RAND_MAX;
 			}
 		}
 	}
-}
-
-double get_initial_temperature()
+}
+
+float get_initial_temperature()
 {
 	return 2.0; // TODO: Figure out what to make this
 }
 
-double get_final_temperature()
+float get_final_temperature()
 {
 	return 0.02; // TODO: Figure out what to make this
 }
@@ -81,7 +81,7 @@ void init_image(Image4f& image)
 {
 	std::fill(image.pBuff_, image.pBuff_+image.width_*image.height_, Color4f(0.0f,0.0f,0.0f,0.0f));
 }
-
+
 void compute_b_array(
 	const Image4f& filter_weights,
 	Image4f& b
@@ -157,7 +157,7 @@ void sum_coarsen(
 {
 	for (int y=0; y<coarse.height_; y++) {
 		for (int x=0; x<coarse.width_; x++) {
-			double divisor = 1.0;
+			float divisor = 1.0;
 			Color4f val = fine[y*2][x*2];
 			if (x*2 + 1 < fine.width_)	 {
 				divisor += 1; val += fine[y*2][x*2 + 1];
@@ -195,7 +195,7 @@ vector<float> extract_vector_layer_1d(const Color4f* s, size_t sz, int k)
 }
 
 int best_match_color(
-	const Array3D<double>& vars,
+	const Array3D<float>& vars,
 	int i_x,
 	int i_y,
 	const Color4f* palette,
@@ -203,7 +203,7 @@ int best_match_color(
 	)
 {
 	int max_v = 0;
-	double max_weight = vars[0][i_y][i_x];
+	float max_weight = vars[0][i_y][i_x];
 	for (size_t v=1; v<num_colors; ++v) {
 		if (vars[v][i_y][i_x] > max_weight) {
 			max_v = v;
@@ -213,7 +213,7 @@ int best_match_color(
 	return max_v;
 }
 
-void zoom_double(const Array3D<double>& small, Array3D<double>& big)
+void zoom(const Array3D<float>& small, Array3D<float>& big)
 {
 	// Simple scaling of the weights array based on mixing the four
 	// pixels falling under each fine pixel, weighted by area.
@@ -221,19 +221,19 @@ void zoom_double(const Array3D<double>& small, Array3D<double>& big)
 	// is 1.2 fine pixels wide and high.
 	for (int y=0; y<big.height_/2*2; y++) {
 		for (int x=0; x<big.width_/2*2; x++) {
-			double left = max(0.0, (x-0.1)/2.0), right	= min(small.width_-0.001, (x+1.1)/2.0);
-			double top	= max(0.0, (y-0.1)/2.0), bottom = min(small.height_-0.001, (y+1.1)/2.0);
+			float left = max(0.0, (x-0.1)/2.0), right	= min(small.width_-0.001, (x+1.1)/2.0);
+			float top	= max(0.0, (y-0.1)/2.0), bottom = min(small.height_-0.001, (y+1.1)/2.0);
 			int x_left = (int)floor(left), x_right	= (int)floor(right);
 			int y_top  = (int)floor(top),  y_bottom = (int)floor(bottom);
-			double area = (right-left)*(bottom-top);
-			double top_left_weight	= (ceil(left) - left)*(ceil(top) - top)/area;
-			double top_right_weight = (right - floor(right))*(ceil(top) - top)/area;
-			double bottom_left_weight  = (ceil(left) - left)*(bottom - floor(bottom))/area;
-			double bottom_right_weight = (right - floor(right))*(bottom - floor(bottom))/area;
-			double top_weight	  = (right-left)*(ceil(top) - top)/area;
-			double bottom_weight  = (right-left)*(bottom - floor(bottom))/area;
-			double left_weight	  = (bottom-top)*(ceil(left) - left)/area;
-			double right_weight	  = (bottom-top)*(right - floor(right))/area;
+			float area = (right-left)*(bottom-top);
+			float top_left_weight	= (ceil(left) - left)*(ceil(top) - top)/area;
+			float top_right_weight = (right - floor(right))*(ceil(top) - top)/area;
+			float bottom_left_weight  = (ceil(left) - left)*(bottom - floor(bottom))/area;
+			float bottom_right_weight = (right - floor(right))*(bottom - floor(bottom))/area;
+			float top_weight	  = (right-left)*(ceil(top) - top)/area;
+			float bottom_weight  = (right-left)*(bottom - floor(bottom))/area;
+			float left_weight	  = (bottom-top)*(ceil(left) - left)/area;
+			float right_weight	  = (bottom-top)*(right - floor(right))/area;
 			for (int z=0; z<big.depth_; z++) {
 				if (x_left == x_right && y_top == y_bottom) {
 					big[z][y][x] = small[z][y_top][x_left];
@@ -256,7 +256,7 @@ void zoom_double(const Array3D<double>& small, Array3D<double>& big)
 
 void compute_initial_s(
 	Image4f& s,
-	const Array3D<double>& coarse_variables,
+	const Array3D<float>& coarse_variables,
 	const Image4f& b
 	)
 {
@@ -282,7 +282,7 @@ void compute_initial_s(
 					Color4f b_ij = b_value(b,i_x,i_y,j_x,j_y);
 					for (int v=0; v<palette_size; v++) {
 						for (int alpha=v; alpha<palette_size; alpha++) {
-							double mult = coarse_variables[v][i_y][i_x] * coarse_variables[alpha][j_y][j_x];
+							float mult = coarse_variables[v][i_y][i_x] * coarse_variables[alpha][j_y][j_x];
 							s[alpha][v][0] += mult * b_ij[0];
 							s[alpha][v][1] += mult * b_ij[1];
 							s[alpha][v][2] += mult * b_ij[2];
@@ -299,12 +299,12 @@ void compute_initial_s(
 
 void update_s(
 	Image4f& s,
-	const Array3D<double>& coarse_variables,
+	const Array3D<float>& coarse_variables,
 	const Image4f& b,
 	int j_x,
 	int j_y,
 	int alpha,
-	double delta
+	float delta
 	)
 {
 	int palette_size  = s.width_;
@@ -318,13 +318,13 @@ void update_s(
 			Color4f delta_b_ij = delta*b_value(b,i_x,i_y,j_x,j_y);
 			if (i_x == j_x && i_y == j_y) continue;
 			for (int v=0; v <= alpha; v++) {
-				double mult = coarse_variables[v][i_y][i_x];
+				float mult = coarse_variables[v][i_y][i_x];
 				s[alpha][v][0] += mult * delta_b_ij[0];
 				s[alpha][v][1] += mult * delta_b_ij[1];
 				s[alpha][v][2] += mult * delta_b_ij[2];
 			}
 			for (int v=alpha; v<palette_size; v++) {
-				double mult = coarse_variables[v][i_y][i_x];
+				float mult = coarse_variables[v][i_y][i_x];
 				s[v][alpha][0] += mult * delta_b_ij[0];
 				s[v][alpha][1] += mult * delta_b_ij[1];
 				s[v][alpha][2] += mult * delta_b_ij[2];
@@ -336,7 +336,7 @@ void update_s(
 
 void refine_palette(
 	Image4f& s,
-	const Array3D<double>& coarse_variables,
+	const Array3D<float>& coarse_variables,
 	const Image4f& a,
 	Color4f* palette,
 	size_t num_colors
@@ -354,7 +354,7 @@ void refine_palette(
 		Color4f sum(0,0,0,0);
 		for (int i_y=0; i_y<coarse_variables.height_; i_y++) {
 			for (int i_x=0; i_x<coarse_variables.width_; i_x++) {
-				double cv = coarse_variables[v][i_y][i_x];
+				float cv = coarse_variables[v][i_y][i_x];
 				Color4f av = a[i_y][i_x];
 				Color4f result = cv * av;
 				sum += result;
@@ -368,7 +368,7 @@ void refine_palette(
 		vector<float> R_k = extract_vector_layer_1d(&r[0], num_colors, k);
 		vector<float> palette_channel = -1.0f*((2.0f*S_k).matrix_inverse())*R_k;
 		for (unsigned int v=0; v<num_colors; v++) {
-			double val = palette_channel[v];
+			float val = palette_channel[v];
 			if (val < 0) val = 0;
 			if (val > 1) val = 1;
 			palette[v][k] = val;
@@ -384,7 +384,7 @@ void refine_palette(
 
 void compute_initial_j_palette_sum(
 	Image4f& j_palette_sum,
-	const Array3D<double>& coarse_variables,
+	const Array3D<float>& coarse_variables,
 	const Color4f* palette,
 	size_t num_colors
 	)
@@ -405,23 +405,23 @@ void spatial_color_quant(
 	Image4f& filter_weights,
 	Array2D<uint8_t>& quantized_image,
 	Color4f* palette, size_t num_colors,
-	Array3D<double>*& p_coarse_variables,
-	double initial_temperature,
-	double final_temperature,
+	Array3D<float>*& p_coarse_variables,
+	float initial_temperature,
+	float final_temperature,
 	int temps_per_level,
 	int repeats_per_temp
 	)
-{
+{
 	int max_coarse_level = //1;
 		compute_max_coarse_level(image.width_, image.height_);
 	size_t width2 = image.width_  >> max_coarse_level;
 	size_t height2 = image.height_ >> max_coarse_level;
-	p_coarse_variables = new Array3D<double>(width2, height2, num_colors);
+	p_coarse_variables = new Array3D<float>(width2, height2, num_colors);
 	// For syntactic convenience
-	Array3D<double>& coarse_variables = *p_coarse_variables;
+	Array3D<float>& coarse_variables = *p_coarse_variables;
 	fill_random(coarse_variables);
 	
-	double temperature = initial_temperature;
+	float temperature = initial_temperature;
 	
 	// Compute a_i, b_{ij} according to (11)
 	int extended_neighborhood_width = filter_weights.width_*2 - 1;
@@ -463,12 +463,12 @@ void spatial_color_quant(
 		Image4f& ai = *p_ai;
 		sum_coarsen(*a_vec.back(), ai);
 		a_vec.push_back(p_ai);
-	}
-	
+	}
+	
 	// Multiscale annealing
 	coarse_level = max_coarse_level;
 	const int iters_per_level = temps_per_level;
-	double temperature_multiplier = pow(final_temperature/initial_temperature, 1.0/(max(3, max_coarse_level*iters_per_level)));
+	float temperature_multiplier = pow(final_temperature/initial_temperature, 1.0f/(max(3, max_coarse_level*iters_per_level)));
 #if TRACE
 	cout << "Temperature multiplier: " << temperature_multiplier << endl;
 #endif
@@ -481,7 +481,7 @@ void spatial_color_quant(
 	compute_initial_j_palette_sum(*j_palette_sum, coarse_variables, palette, num_colors);
 	while (coarse_level >= 0 || temperature > final_temperature) {
 		// Need to reseat this reference in case we changed p_coarse_variables
-		Array3D<double>& coarse_variables = *p_coarse_variables;
+		Array3D<float>& coarse_variables = *p_coarse_variables;
 		Image4f& a = *a_vec[coarse_level];
 		Image4f& b = *b_vec[coarse_level];
 		Color4f middle_b = b_value(b,0,0,0,0);
@@ -553,7 +553,7 @@ void spatial_color_quant(
 					// Prevent the matrix S from becoming singular
 					if (new_val <= 0) new_val = 1e-10;
 					if (new_val >= 1) new_val = 1 - 1e-10;
-					double delta_m_iv = new_val - coarse_variables[v][i_y][i_x];
+					float delta_m_iv = new_val - coarse_variables[v][i_y][i_x];
 					coarse_variables[v][i_y][i_x] = new_val;
 					j_pal[0] += delta_m_iv*palette[v][0];
 					j_pal[1] += delta_m_iv*palette[v][1];
@@ -612,11 +612,11 @@ void spatial_color_quant(
 		{
 			coarse_level--;
 			if (coarse_level < 0) break;
-			Array3D<double>* p_new_coarse_variables = new Array3D<double>(
+			Array3D<float>* p_new_coarse_variables = new Array3D<float>(
 				image.width_  >> coarse_level,
 				image.height_ >> coarse_level,
 				num_colors);
-			zoom_double(coarse_variables, *p_new_coarse_variables);
+			zoom(coarse_variables, *p_new_coarse_variables);
 			delete p_coarse_variables;
 			p_coarse_variables = p_new_coarse_variables;
 			iters_at_current_level = 0;
@@ -636,19 +636,19 @@ void spatial_color_quant(
 	// This is normally not used, but is handy sometimes for debugging
 	while (coarse_level > 0) {
 		coarse_level--;
-		Array3D<double>* p_new_coarse_variables = new Array3D<double>(
+		Array3D<float>* p_new_coarse_variables = new Array3D<float>(
 			image.width_  >> coarse_level,
 			image.height_ >> coarse_level,
 			num_colors
 			);
-		zoom_double(*p_coarse_variables, *p_new_coarse_variables);
+		zoom(*p_coarse_variables, *p_new_coarse_variables);
 		delete p_coarse_variables;
 		p_coarse_variables = p_new_coarse_variables;
 	}
 	
 	{
 		// Need to reseat this reference in case we changed p_coarse_variables
-		Array3D<double>& coarse_variables = *p_coarse_variables;
+		Array3D<float>& coarse_variables = *p_coarse_variables;
 
 		for (int i_x = 0; i_x < image.width_; i_x++) {
 			for (int i_y = 0; i_y < image.height_; i_y++) {
@@ -666,6 +666,6 @@ void spatial_color_quant(
 	#endif
 		}
 	}
-
-}
-
+
+}
+

--- a/quantize.h
+++ b/quantize.h
@@ -5,9 +5,9 @@ void spatial_color_quant(
 	Image4f& filter_weights,
 	Array2D<uint8_t>& quantized_image,
 	Color4f* palette, size_t num_colors,
-	Array3D<double>*& p_coarse_variables,
-	double initial_temperature,
-	double final_temperature,
+	Array3D<float>*& p_coarse_variables,
+	float initial_temperature,
+	float final_temperature,
 	int temps_per_level,
 	int repeats_per_temp
 );