Publish LumaOps source

qt/hsv.cpp

@@ -0,0 +1,159 @@
+/*
+* RGB <--> HSV conversion in integer arithmetics, to be used on Windows.
+* Copyright (c) 2013 Martin Mitas
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 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 "hsv.h"
+
+
+#define MIN(a,b)      ((a) < (b) ? (a) : (b))
+#define MAX(a,b)      ((a) > (b) ? (a) : (b))
+
+#define MIN3(a,b,c)   MIN((a), MIN((b), (c)))
+#define MAX3(a,b,c)   MAX((a), MAX((b), (c)))
+
+#define RGBGetRValue(rgb)   (rgb & 0x000000FF)
+#define RGBGetGValue(rgb)   ((rgb >> 8) & 0x000000FF)
+#define RGBGetBValue(rgb)   ((rgb >> 16) & 0x000000FF)
+
+#define ToRGBColor(r, g, b) ((b << 16) | (g << 8) | (r))
+
+void rgb2hsv(unsigned int rgb, hsv_t* hsv)
+{
+    int r = RGBGetRValue(rgb);
+    int g = RGBGetGValue(rgb);
+    int b = RGBGetBValue(rgb);
+	int m = MIN3(r, g, b);
+	int M = MAX3(r, g, b);
+	int delta = M - m;
+
+	if (delta == 0) {
+		/* Achromatic case (i.e. grayscale) */
+		hsv->hue = -1;          /* undefined */
+		hsv->saturation = 0;
+	}
+	else {
+		int h;
+
+		if (r == M)
+			h = ((g - b) * 60 * HUE_DEGREE) / delta;
+		else if (g == M)
+			h = ((b - r) * 60 * HUE_DEGREE) / delta + 120 * HUE_DEGREE;
+		else /*if(b == M)*/
+			h = ((r - g) * 60 * HUE_DEGREE) / delta + 240 * HUE_DEGREE;
+
+		if (h < 0)
+			h += 360 * HUE_DEGREE;
+
+		hsv->hue = h;
+
+		/* The constatnt 8 is tuned to statistically cause as little
+		* tolerated mismatches as possible in RGB -> HSV -> RGB conversion.
+		* (See the unit test at the bottom of this file.)
+		*/
+		hsv->saturation = (256 * delta - 8) / M;
+	}
+	hsv->value = M;
+}
+
+unsigned int hsv2rgb(hsv_t* hsv)
+{
+    unsigned char r = 0;
+	unsigned char g = 0;
+	unsigned char b = 0;
+
+	if (hsv->saturation == 0) {
+		r = g = b = hsv->value;
+	}
+	else {
+		int h = (hsv->hue)%360;
+		int s = hsv->saturation;
+		int v = hsv->value;
+		int i = h / (60 * HUE_DEGREE);
+		int p = (256 * v - s*v) / 256;
+
+		if (i & 1) {
+			int q = (256 * 60 * HUE_DEGREE*v - h*s*v + 60 * HUE_DEGREE*s*v*i) / (256 * 60 * HUE_DEGREE);
+			switch (i) {
+			case 1:   r = q; g = v; b = p; break;
+			case 3:   r = p; g = q; b = v; break;
+			case 5:   r = v; g = p; b = q; break;
+			}
+		}
+		else {
+			int t = (256 * 60 * HUE_DEGREE*v + h*s*v - 60 * HUE_DEGREE*s*v*(i + 1)) / (256 * 60 * HUE_DEGREE);
+			switch (i) {
+			case 0:   r = v; g = t; b = p; break;
+			case 2:   r = p; g = v; b = t; break;
+			case 4:   r = t; g = p; b = v; break;
+			}
+		}
+	}
+
+    return ToRGBColor(r, g, b);
+}
+
+
+#ifdef TEST
+
+#include <stdio.h>
+
+#define DIFF(a,b)     ((a) >= (b) ? (a) - (b) : (b) - (a))
+
+int
+main(int argc, char** argv)
+{
+	int r0, g0, b0;
+	hsv_t hsv;
+	int r1, g1, b1;
+	int ok = 0, fuzzy = 0, ko = 0, total;
+
+	for (r0 = 0; r0 < 256; r0++) {
+		for (g0 = 0; g0 < 256; g0++) {
+			for (b0 = 0; b0 < 256; b0++) {
+				COLORREF tmp;
+
+				rgb2hsv(RGB(r0, g0, b0), &hsv);
+				tmp = hsv2rgb(&hsv);
+				r1 = GetRValue(tmp);
+				g1 = GetGValue(tmp);
+				b1 = GetBValue(tmp);
+
+				if (r0 == r1 && b0 == b1 && g0 == g1)
+					ok++;
+				else if (DIFF(r0, r1) <= 1 && DIFF(b0, b1) <= 1 && DIFF(g0, g1) <= 1)
+					fuzzy++;
+				else
+					ko++;
+			}
+		}
+	}
+
+	total = ok + fuzzy + ko;
+
+	printf("Test results:\n");
+	printf("  * exact matches: %8d (%5.2f%%)\n", ok, (100.0 * ok) / total);
+	printf("  * fuzzy matches: %8d (%5.2f%%)\n", fuzzy, (100.0 * fuzzy) / total);
+	printf("  * mismatches:    %8d (%5.2f%%)\n", ko, (100.0 * ko) / total);
+
+	return (ko == 0 ? 0 : 1);
+}
+#endif  /* TEST */