First commit - moving from LuaForge to SourceForge

1 files changed, 883 insertions, 0 deletions

diff --git a/src/im_convertcolor.cpp b/src/im_convertcolor.cpp
new file mode 100644
index 0000000..4068b94
--- /dev/null
+++ b/src/im_convertcolor.cpp
@@ -0,0 +1,883 @@
+/** \file
+ * \brief Image Conversion
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: im_convertcolor.cpp,v 1.1 2008/10/17 06:10:16 scuri Exp $
+ */
+
+#include "im.h"
+#include "im_util.h"
+#include "im_complex.h"
+#include "im_image.h"
+#include "im_convert.h"
+#include "im_color.h"
+#include "im_counter.h"
+
+#include <stdlib.h>
+#include <assert.h>
+#include <memory.h>
+
+void imConvertMapToRGB(unsigned char* data, int count, int depth, int packed, long* palette, int palette_count)
+{
+  int c, i, delta;
+  unsigned char r[256], g[256], b[256];
+  unsigned char *r_data, *g_data, *b_data;
+
+  unsigned char* src_data = data + count-1;
+  if (packed)
+  {
+    r_data = data + depth*(count-1);
+    g_data = r_data + 1;
+    b_data = r_data + 2;
+    delta = depth;
+  }
+  else
+  {
+    r_data = data +   count - 1;
+    g_data = data + 2*count - 1;
+    b_data = data + 3*count - 1;
+    delta = 1;
+  }
+
+  for (c = 0; c < palette_count; c++)
+    imColorDecode(&r[c], &g[c], &b[c], palette[c]);
+
+  for (i = 0; i < count; i++)
+  {
+    int index = *src_data;
+    *r_data = r[index];
+    *g_data = g[index];
+    *b_data = b[index];
+
+    r_data -= delta;
+    g_data -= delta;
+    b_data -= delta;
+    src_data--;
+  }
+}
+
+// convert bin2gray and gray2bin
+inline void iConvertBinary(imbyte* map, int count, imbyte value)
+{
+  imbyte thres = (value == 255)? 1: 128;
+
+  // if gray2bin, check for invalid gray that already is binary
+  if (value != 255)
+  {
+    imbyte vmax = 0, *pmap = map;
+    for (int i = 0; i < count; i++)
+    {
+      if (*pmap > vmax)
+        vmax = *pmap;
+
+      pmap++;
+    }
+
+    if (vmax == 1)
+      thres = 1;
+    else
+      thres = vmax / 2;
+  }
+
+  for (int i = 0; i < count; i++)
+  {
+    if (*map >= thres)
+      *map = value;
+    else
+      *map = 0;
+
+    map++;
+  }
+}
+
+static void iConvertMap2Gray(const imbyte* src_map, imbyte* dst_map, int count, const long* palette, const int palette_count)
+{
+  imbyte r, g, b;
+  imbyte remap[256];
+
+  for (int c = 0; c < palette_count; c++)
+  {
+    imColorDecode(&r, &g, &b, palette[c]);
+    remap[c] = imColorRGB2Luma(r, g, b);
+  }
+
+  for (int i = 0; i < count; i++)
+  {
+    *dst_map++ = remap[*src_map++];
+  }
+}
+
+static void iConvertMapToRGB(const imbyte* src_map, imbyte* red, imbyte* green, imbyte* blue, int count, const long* palette, const int palette_count)
+{
+  imbyte r[256], g[256], b[256];
+  for (int c = 0; c < palette_count; c++)
+    imColorDecode(&r[c], &g[c], &b[c], palette[c]);
+
+  for (int i = 0; i < count; i++)
+  {
+    int index = *src_map++;
+    *red++ = r[index];
+    *green++ = g[index];
+    *blue++ = b[index];
+  }
+}
+
+template <class T> 
+int iDoConvert2Gray(int count, int data_type, 
+                           const T** src_data, int src_color_space, T** dst_data, int counter)
+{
+  int i;
+  T max;
+
+  const T* src_map0 = src_data[0];
+  const T* src_map1 = src_data[1];
+  const T* src_map2 = src_data[2];
+  const T* src_map3 = (src_color_space == IM_CMYK)? src_data[3]: 0;
+  T* dst_map = dst_data[0];
+
+  imCounterTotal(counter, count, "Converting To Gray...");
+
+  switch(src_color_space)
+  {
+  case IM_XYZ: 
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // scale to 0-1
+      float c1 = imColorReconstruct(*src_map1++, max);  // use only Y component
+
+      // do gamma correction then scale back to 0-max
+      *dst_map++ = imColorQuantize(imColorTransfer2Nonlinear(c1), max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  case IM_CMYK: 
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      T r, g, b;
+      // result is still 0-max
+      imColorCMYK2RGB(*src_map0++, *src_map1++, *src_map2++, *src_map3++, r, g, b, max);
+      *dst_map++ = imColorRGB2Luma(r, g, b);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  case IM_RGB:
+    for (i = 0; i < count; i++)
+    {
+      *dst_map++ = imColorRGB2Luma(*src_map0++, *src_map1++, *src_map2++);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  case IM_LUV:
+  case IM_LAB:
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // to increase precision do intermediate conversions in float
+      
+      float c0 = imColorReconstruct(*src_map0++, max); // scale to 0-1
+      c0 = imColorLightness2Luminance(c0);             // do the convertion
+
+      // do gamma correction then scale back to 0-max
+      *dst_map++ = imColorQuantize(imColorTransfer2Nonlinear(c0), max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  default:
+    return IM_ERR_DATA;
+  }
+
+  return IM_ERR_NONE;
+}
+
+template <class T> 
+int iDoConvert2RGB(int count, int data_type, 
+                          const T** src_data, int src_color_space, T** dst_data, int counter)
+{
+  int i;
+  T max, zero;
+
+  const T* src_map0 = src_data[0];
+  const T* src_map1 = src_data[1];
+  const T* src_map2 = src_data[2];
+  const T* src_map3 = (src_color_space == IM_CMYK)? src_data[3]: 0;
+  T* dst_map0 = dst_data[0];
+  T* dst_map1 = dst_data[1];
+  T* dst_map2 = dst_data[2];
+
+  imCounterTotal(counter, count, "Converting To RGB...");
+
+  switch(src_color_space)
+  {
+  case IM_XYZ: 
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // to increase precision do intermediate conversions in float
+
+      // scale to 0-1
+      float c0 = imColorReconstruct(*src_map0++, max);
+      float c1 = imColorReconstruct(*src_map1++, max);
+      float c2 = imColorReconstruct(*src_map2++, max);
+
+      // result is still 0-1
+      imColorXYZ2RGB(c0, c1, c2, 
+                     c0, c1, c2, 1.0f);
+
+      // do gamma correction then scale back to 0-max
+      *dst_map0++ = imColorQuantize(imColorTransfer2Nonlinear(c0), max);
+      *dst_map1++ = imColorQuantize(imColorTransfer2Nonlinear(c1), max);
+      *dst_map2++ = imColorQuantize(imColorTransfer2Nonlinear(c2), max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  case IM_YCBCR: 
+    max = (T)imColorMax(data_type);
+    zero = (T)imColorZero(data_type);
+    for (i = 0; i < count; i++)
+    {
+      imColorYCbCr2RGB(*src_map0++, *src_map1++, *src_map2++, 
+                       *dst_map0++, *dst_map1++, *dst_map2++, zero, max);
+    }
+    break;
+  case IM_CMYK: 
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // result is still 0-max
+      imColorCMYK2RGB(*src_map0++, *src_map1++, *src_map2++, *src_map3++, 
+                      *dst_map0++, *dst_map1++, *dst_map2++, max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  case IM_LUV:
+  case IM_LAB:
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // to increase precision do intermediate conversions in float
+
+      // scale to 0-1 and -0.5/+0.5
+      float c0 = imColorReconstruct(*src_map0++, max);
+      float c1 = imColorReconstruct(*src_map1++, max) - 0.5f;
+      float c2 = imColorReconstruct(*src_map2++, max) - 0.5f;
+
+      if (src_color_space == IM_LUV)
+        imColorLuv2XYZ(c0, c1, c2,  // conversion in-place
+                       c0, c1, c2);
+      else
+        imColorLab2XYZ(c0, c1, c2,  // conversion in-place
+                       c0, c1, c2);
+
+      imColorXYZ2RGB(c0, c1, c2,    // conversion in-place
+                     c0, c1, c2, 1.0f);
+
+      // do gamma correction then scale back to 0-max
+      *dst_map0++ = imColorQuantize(imColorTransfer2Nonlinear(c0), max);
+      *dst_map1++ = imColorQuantize(imColorTransfer2Nonlinear(c1), max);
+      *dst_map2++ = imColorQuantize(imColorTransfer2Nonlinear(c2), max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  default:
+    return IM_ERR_DATA;
+  }
+
+  return IM_ERR_NONE;
+}
+
+template <class T> 
+int iDoConvert2YCbCr(int count, int data_type, 
+                            const T** src_data, int src_color_space, T** dst_data, int counter)
+{
+  int i;
+  T zero;
+
+  const T* src_map0 = src_data[0];
+  const T* src_map1 = src_data[1];
+  const T* src_map2 = src_data[2];
+  T* dst_map0 = dst_data[0];
+  T* dst_map1 = dst_data[1];
+  T* dst_map2 = dst_data[2];
+
+  imCounterTotal(counter, count, "Converting To YCbCr...");
+
+  switch(src_color_space)
+  {
+  case IM_RGB: 
+    zero = (T)imColorZero(data_type);
+    for (i = 0; i < count; i++)
+    {
+      imColorRGB2YCbCr(*src_map0++, *src_map1++, *src_map2++, 
+                       *dst_map0++, *dst_map1++, *dst_map2++, zero);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  default:
+    return IM_ERR_DATA;
+  }
+
+  return IM_ERR_NONE;
+}
+
+template <class T> 
+int iDoConvert2XYZ(int count, int data_type, 
+                          const T** src_data, int src_color_space, T** dst_data, int counter)
+{
+  int i;
+  T max;
+
+  const T* src_map0 = src_data[0];
+  const T* src_map1 = (src_color_space == IM_GRAY)? 0: src_data[1];
+  const T* src_map2 = (src_color_space == IM_GRAY)? 0: src_data[2];
+  T* dst_map0 = dst_data[0];
+  T* dst_map1 = dst_data[1];
+  T* dst_map2 = dst_data[2];
+
+  imCounterTotal(counter, count, "Converting To XYZ...");
+
+  switch(src_color_space)
+  {
+  case IM_GRAY: 
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // scale to 0-1
+      float c0 = imColorReconstruct(*src_map0++, max);
+
+      // do gamma correction
+      c0 = imColorTransfer2Linear(c0);
+
+      // then scale back to 0-max
+      *dst_map0++ = imColorQuantize(c0*0.9505f, max);    // Compensate D65 white point
+      *dst_map1++ = imColorQuantize(c0, max);
+      *dst_map2++ = imColorQuantize(c0*1.0890f, max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  case IM_RGB: 
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // to increase precision do intermediate conversions in float
+
+      // scale to 0-1
+      float c0 = imColorReconstruct(*src_map0++, max);
+      float c1 = imColorReconstruct(*src_map1++, max);
+      float c2 = imColorReconstruct(*src_map2++, max);
+
+      // do gamma correction
+      c0 = imColorTransfer2Linear(c0);
+      c1 = imColorTransfer2Linear(c1);
+      c2 = imColorTransfer2Linear(c2);
+
+      // result is still 0-1
+      imColorRGB2XYZ(c0, c1, c2, 
+                     c0, c1, c2);
+
+      // then scale back to 0-max
+      *dst_map0++ = imColorQuantize(c0, max);
+      *dst_map1++ = imColorQuantize(c1, max);
+      *dst_map2++ = imColorQuantize(c2, max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  case IM_LUV:
+  case IM_LAB:
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // to increase precision do intermediate conversions in float
+      // scale to 0-1 and -0.5/+0.5
+      float c0 = imColorReconstruct(*src_map0++, max);
+      float c1 = imColorReconstruct(*src_map1++, max) - 0.5f;
+      float c2 = imColorReconstruct(*src_map2++, max) - 0.5f;
+
+      if (src_color_space == IM_LUV)
+        imColorLuv2XYZ(c0, c1, c2,  // convertion in-place
+                       c0, c1, c2);
+      else
+        imColorLab2XYZ(c0, c1, c2,  // convertion in-place
+                       c0, c1, c2);
+
+      // scale back to 0-max
+      *dst_map0++ = imColorQuantize(c0, max);
+      *dst_map1++ = imColorQuantize(c1, max);
+      *dst_map2++ = imColorQuantize(c2, max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  default:
+    return IM_ERR_DATA;
+  }
+
+  return IM_ERR_NONE;
+}
+
+template <class T> 
+int iDoConvert2Lab(int count, int data_type, 
+                          const T** src_data, int src_color_space, T** dst_data, int counter)
+{
+  int i;
+  T max;
+
+  const T* src_map0 = src_data[0];
+  const T* src_map1 = (src_color_space == IM_GRAY)? 0: src_data[1];
+  const T* src_map2 = (src_color_space == IM_GRAY)? 0: src_data[2];
+  T* dst_map0 = dst_data[0];
+  T* dst_map1 = dst_data[1];
+  T* dst_map2 = dst_data[2];
+
+  imCounterTotal(counter, count, "Converting To Lab...");
+
+  switch(src_color_space)
+  {
+  case IM_GRAY: 
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // scale to 0-1
+      float c0 = imColorReconstruct(*src_map0++, max);
+
+      // do gamma correction
+      c0 = imColorTransfer2Linear(c0);
+
+      // do conversion
+      c0 = imColorLuminance2Lightness(c0);
+
+      // then scale back to 0-max
+      *dst_map0++ = imColorQuantize(c0, max);  // update only the L component
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  case IM_RGB: 
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // to increase precision do intermediate conversions in float
+
+      // scale to 0-1
+      float c0 = imColorReconstruct(*src_map0++, max);
+      float c1 = imColorReconstruct(*src_map1++, max);
+      float c2 = imColorReconstruct(*src_map2++, max);
+
+      // do gamma correction
+      c0 = imColorTransfer2Linear(c0);
+      c1 = imColorTransfer2Linear(c1);
+      c2 = imColorTransfer2Linear(c2);
+
+      imColorRGB2XYZ(c0, c1, c2,  // convertion in-place
+                     c0, c1, c2);
+
+      imColorXYZ2Lab(c0, c1, c2,  // convertion in-place
+                     c0, c1, c2);
+
+      // then scale back to 0-max
+      *dst_map0++ = imColorQuantize(c0, max);
+      *dst_map1++ = imColorQuantize(c1 + 0.5f, max);
+      *dst_map2++ = imColorQuantize(c2 + 0.5f, max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  case IM_XYZ:
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // to increase precision do intermediate conversions in float
+      // scale to 0-1 and -0.5/+0.5
+      float c0 = imColorReconstruct(*src_map0++, max);
+      float c1 = imColorReconstruct(*src_map1++, max);
+      float c2 = imColorReconstruct(*src_map2++, max);
+
+      imColorXYZ2Lab(c0, c1, c2,  // convertion in-place
+                     c0, c1, c2);
+
+      // scale back to 0-max
+      *dst_map0++ = imColorQuantize(c0, max);
+      *dst_map1++ = imColorQuantize(c1 + 0.5f, max);
+      *dst_map2++ = imColorQuantize(c2 + 0.5f, max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  case IM_LUV:
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // to increase precision do intermediate conversions in float
+      // scale to 0-1 and -0.5/+0.5
+      float c0 = imColorReconstruct(*src_map0++, max);
+      float c1 = imColorReconstruct(*src_map1++, max) - 0.5f;
+      float c2 = imColorReconstruct(*src_map2++, max) - 0.5f;
+
+      imColorLuv2XYZ(c0, c1, c2,  // convertion in-place
+                     c0, c1, c2);
+      imColorXYZ2Lab(c0, c1, c2,  // convertion in-place
+                     c0, c1, c2);
+
+      // scale back to 0-max
+      *dst_map0++ = imColorQuantize(c0, max);
+      *dst_map1++ = imColorQuantize(c1 + 0.5f, max);
+      *dst_map2++ = imColorQuantize(c2 + 0.5f, max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  default:
+    return IM_ERR_DATA;
+  }
+
+  return IM_ERR_NONE;
+}
+
+template <class T> 
+int iDoConvert2Luv(int count, int data_type, 
+                          const T** src_data, int src_color_space, T** dst_data, int counter)
+{
+  int i;
+  T max;
+
+  const T* src_map0 = src_data[0];
+  const T* src_map1 = (src_color_space == IM_GRAY)? 0: src_data[1];
+  const T* src_map2 = (src_color_space == IM_GRAY)? 0: src_data[2];
+  T* dst_map0 = dst_data[0];
+  T* dst_map1 = dst_data[1];
+  T* dst_map2 = dst_data[2];
+
+  imCounterTotal(counter, count, "Converting To Luv...");
+
+  switch(src_color_space)
+  {
+  case IM_GRAY: 
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // scale to 0-1
+      float c0 = imColorReconstruct(*src_map0++, max);
+
+      // do gamma correction
+      c0 = imColorTransfer2Linear(c0);
+
+      // do conversion
+      c0 = imColorLuminance2Lightness(c0);
+
+      // then scale back to 0-max
+      *dst_map0++ = imColorQuantize(c0, max);  // update only the L component
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  case IM_RGB: 
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // to increase precision do intermediate conversions in float
+
+      // scale to 0-1
+      float c0 = imColorReconstruct(*src_map0++, max);
+      float c1 = imColorReconstruct(*src_map1++, max);
+      float c2 = imColorReconstruct(*src_map2++, max);
+
+      // do gamma correction
+      c0 = imColorTransfer2Linear(c0);
+      c1 = imColorTransfer2Linear(c1);
+      c2 = imColorTransfer2Linear(c2);
+
+      imColorRGB2XYZ(c0, c1, c2,  // convertion in-place
+                     c0, c1, c2);
+
+      imColorXYZ2Luv(c0, c1, c2,  // convertion in-place
+                     c0, c1, c2);
+
+      // then scale back to 0-max
+      *dst_map0++ = imColorQuantize(c0, max);
+      *dst_map1++ = imColorQuantize(c1 + 0.5f, max);
+      *dst_map2++ = imColorQuantize(c2 + 0.5f, max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  case IM_XYZ:
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // to increase precision do intermediate conversions in float
+      // scale to 0-1 and -0.5/+0.5
+      float c0 = imColorReconstruct(*src_map0++, max);
+      float c1 = imColorReconstruct(*src_map1++, max);
+      float c2 = imColorReconstruct(*src_map2++, max);
+
+      imColorXYZ2Luv(c0, c1, c2,  // convertion in-place
+                     c0, c1, c2);
+
+      // scale back to 0-max
+      *dst_map0++ = imColorQuantize(c0, max);
+      *dst_map1++ = imColorQuantize(c1 + 0.5f, max);
+      *dst_map2++ = imColorQuantize(c2 + 0.5f, max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  case IM_LAB:
+    max = (T)imColorMax(data_type);
+    for (i = 0; i < count; i++)
+    {
+      // to increase precision do intermediate conversions in float
+      // scale to 0-1 and -0.5/+0.5
+      float c0 = imColorReconstruct(*src_map0++, max);
+      float c1 = imColorReconstruct(*src_map1++, max) - 0.5f;
+      float c2 = imColorReconstruct(*src_map2++, max) - 0.5f;
+
+      imColorLab2XYZ(c0, c1, c2,  // convertion in-place
+                     c0, c1, c2);
+      imColorXYZ2Luv(c0, c1, c2,  // convertion in-place
+                     c0, c1, c2);
+
+      // scale back to 0-max
+      *dst_map0++ = imColorQuantize(c0, max);
+      *dst_map1++ = imColorQuantize(c1 + 0.5f, max);
+      *dst_map2++ = imColorQuantize(c2 + 0.5f, max);
+
+      if (!imCounterInc(counter))
+        return IM_ERR_COUNTER;
+    }
+    break;
+  default:
+    return IM_ERR_DATA;
+  }
+
+  return IM_ERR_NONE;
+}
+
+template <class T> 
+int iDoConvertColorSpace(int count, int data_type, 
+                                 const T** src_data, int src_color_space, 
+                                       T** dst_data, int dst_color_space)
+{
+  int ret = IM_ERR_DATA, 
+      convert2rgb = 0;
+
+  if ((dst_color_space == IM_XYZ ||
+       dst_color_space == IM_LAB ||
+       dst_color_space == IM_LUV) && 
+      (src_color_space == IM_CMYK ||
+       src_color_space == IM_YCBCR))
+  {
+    convert2rgb = 1;
+  }    
+
+  if (dst_color_space == IM_YCBCR && src_color_space != IM_RGB)
+    convert2rgb = 1;
+
+  int counter = imCounterBegin("Convert Color Space");
+
+  if (convert2rgb)
+  {
+    ret = iDoConvert2RGB(count, data_type, src_data, src_color_space, dst_data, counter);     
+
+    if (ret != IM_ERR_NONE) 
+    {
+      imCounterEnd(counter);
+      return ret;
+    }
+
+    src_data = (const T**)dst_data;
+    src_color_space = IM_RGB;
+  }
+
+  switch(dst_color_space)
+  {
+  case IM_GRAY: 
+    ret = iDoConvert2Gray(count, data_type, src_data, src_color_space, dst_data, counter);
+    break;
+  case IM_RGB: 
+    ret = iDoConvert2RGB(count, data_type, src_data, src_color_space, dst_data, counter);
+    break;
+  case IM_YCBCR: 
+    ret = iDoConvert2YCbCr(count, data_type, src_data, src_color_space, dst_data, counter); 
+    break;
+  case IM_XYZ: 
+    ret = iDoConvert2XYZ(count, data_type, src_data, src_color_space, dst_data, counter);
+    break;
+  case IM_LAB: 
+    ret = iDoConvert2Lab(count, data_type, src_data, src_color_space, dst_data, counter);
+    break;
+  case IM_LUV: 
+    ret = iDoConvert2Luv(count, data_type, src_data, src_color_space, dst_data, counter);
+    break;
+  default:
+    ret = IM_ERR_DATA;
+    break;
+  }
+
+  imCounterEnd(counter);
+
+  return ret;
+}
+
+static int iConvertColorSpace(const imImage* src_image, imImage* dst_image)
+{
+  switch(src_image->data_type)
+  {
+  case IM_BYTE:
+    return iDoConvertColorSpace(src_image->count, src_image->data_type,
+                         (const imbyte**)src_image->data, src_image->color_space, 
+                               (imbyte**)dst_image->data, dst_image->color_space);
+  case IM_USHORT:
+    return iDoConvertColorSpace(src_image->count, src_image->data_type, 
+                         (const imushort**)src_image->data, src_image->color_space, 
+                               (imushort**)dst_image->data, dst_image->color_space);
+  case IM_INT:
+    return iDoConvertColorSpace(src_image->count, src_image->data_type,
+                         (const int**)src_image->data, src_image->color_space, 
+                               (int**)dst_image->data, dst_image->color_space);
+  case IM_FLOAT:
+    return iDoConvertColorSpace(src_image->count, src_image->data_type, 
+                         (const float**)src_image->data, src_image->color_space, 
+                               (float**)dst_image->data, dst_image->color_space);
+  case IM_CFLOAT:
+    /* treat complex as two real values */
+    return iDoConvertColorSpace(2*src_image->count, src_image->data_type,
+                         (const float**)src_image->data, src_image->color_space, 
+                               (float**)dst_image->data, dst_image->color_space);
+  }
+
+  return IM_ERR_DATA;
+}
+
+int imConvertColorSpace(const imImage* src_image, imImage* dst_image)
+{
+  assert(src_image);
+  assert(dst_image);
+
+  if (!imImageMatchDataType(src_image, dst_image))
+    return IM_ERR_DATA;
+
+  if (src_image->color_space == dst_image->color_space)
+    return IM_ERR_DATA;
+
+  switch(dst_image->color_space)
+  {
+  case IM_RGB:
+    switch(src_image->color_space)
+    {
+    case IM_BINARY:
+        memcpy(dst_image->data[0], src_image->data[0], dst_image->plane_size);
+        iConvertBinary((imbyte*)dst_image->data[0], dst_image->count, 255);
+        memcpy(dst_image->data[1], dst_image->data[0], dst_image->plane_size);
+        memcpy(dst_image->data[2], dst_image->data[0], dst_image->plane_size);
+      return IM_ERR_NONE;
+    case IM_MAP:
+      iConvertMapToRGB((imbyte*)src_image->data[0], (imbyte*)dst_image->data[0], (imbyte*)dst_image->data[1], (imbyte*)dst_image->data[2], dst_image->count, src_image->palette, src_image->palette_count);
+      return IM_ERR_NONE;
+    case IM_GRAY:
+        memcpy(dst_image->data[0], src_image->data[0], dst_image->plane_size);
+        memcpy(dst_image->data[1], src_image->data[0], dst_image->plane_size);
+        memcpy(dst_image->data[2], src_image->data[0], dst_image->plane_size);
+      return IM_ERR_NONE;
+    default: 
+      return iConvertColorSpace(src_image, dst_image);
+    }
+  case IM_GRAY:  
+    switch(src_image->color_space)
+    {
+    case IM_BINARY:
+      memcpy(dst_image->data[0], src_image->data[0], dst_image->size);
+      iConvertBinary((imbyte*)dst_image->data[0], dst_image->count, 255);
+      return IM_ERR_NONE;
+    case IM_MAP:
+      iConvertMap2Gray((imbyte*)src_image->data[0], (imbyte*)dst_image->data[0], dst_image->count, src_image->palette, src_image->palette_count);
+      return IM_ERR_NONE;
+    case IM_YCBCR: 
+      memcpy(dst_image->data[0], src_image->data[0], dst_image->plane_size);
+      return IM_ERR_NONE;
+    default:
+      return iConvertColorSpace(src_image, dst_image);
+    }
+  case IM_MAP:   
+    switch(src_image->color_space)
+    {
+    case IM_BINARY: // no break, same procedure as gray
+    case IM_GRAY:
+      memcpy(dst_image->data[0], src_image->data[0], dst_image->size);
+      dst_image->palette_count = src_image->palette_count;
+      memcpy(dst_image->palette, src_image->palette, dst_image->palette_count*sizeof(long));
+      return IM_ERR_NONE;
+    case IM_RGB:
+      dst_image->palette_count = 256;
+      return imConvertRGB2Map(src_image->width, src_image->height, 
+                             (imbyte*)src_image->data[0], (imbyte*)src_image->data[1], (imbyte*)src_image->data[2], 
+                             (imbyte*)dst_image->data[0], dst_image->palette, &dst_image->palette_count);
+    default:
+      return IM_ERR_DATA;
+    }
+  case IM_BINARY:
+    switch(src_image->color_space)
+    {
+    case IM_GRAY:
+      memcpy(dst_image->data[0], src_image->data[0], dst_image->size);
+      iConvertBinary((imbyte*)dst_image->data[0], dst_image->count, 1);
+      return IM_ERR_NONE;
+    case IM_MAP:           // convert to gray, then convert to binary
+      iConvertMap2Gray((imbyte*)src_image->data[0], (imbyte*)dst_image->data[0], dst_image->count, src_image->palette, src_image->palette_count);
+      iConvertBinary((imbyte*)dst_image->data[0], dst_image->count, 1);
+      return IM_ERR_NONE;
+    case IM_YCBCR:         // convert to gray, then convert to binary
+      memcpy(dst_image->data[0], src_image->data[0], dst_image->plane_size);
+      iConvertBinary((imbyte*)dst_image->data[0], dst_image->count, 1);
+      return IM_ERR_NONE;
+    default:               // convert to gray, then convert to binary
+      {
+        dst_image->color_space = IM_GRAY;
+        int ret = iConvertColorSpace(src_image, dst_image);
+        dst_image->color_space = IM_BINARY;
+        if (ret != IM_ERR_NONE) return ret;
+        iConvertBinary((imbyte*)dst_image->data[0], dst_image->count, 1);
+        return IM_ERR_NONE;
+      }
+    }
+  case IM_YCBCR: 
+    switch(src_image->color_space)
+    {
+    case IM_GRAY:
+      memcpy(dst_image->data[0], src_image->data[0], dst_image->plane_size);
+      return IM_ERR_NONE;
+    default:
+      return iConvertColorSpace(src_image, dst_image);
+    }
+  default: 
+    return iConvertColorSpace(src_image, dst_image);
+  }
+}