ruby-iup 0.0.2 → 0.1.0

data/ext/iup-mswin32/include/im_colorhsi.h

@@ -0,0 +1,56 @@
+/** \file
+ * \brief HSI Color Manipulation
+ *
+ * See Copyright Notice in im_lib.h
+ */
+
+#ifndef __IM_COLORHSI_H
+#define __IM_COLORHSI_H
+
+#if	defined(__cplusplus)
+extern "C" {
+#endif
+
+
+/** \defgroup hsi HSI Color Coordinate System Conversions
+ *
+ * \par
+ * HSI is just the RGB color space written in a different coordinate system.
+ * \par
+ * "I" is defined along the cube diagonal. It ranges from 0 (black) to 1 (white). \n
+ * HS are the polar coordinates of a plane normal to "I". \n
+ * "S" is the normal distance from the diagonal of the RGB cube. It ranges from 0 to 1. \n
+ * "H" is the angle starting from the red vector, given in degrees.
+ * \par
+ * This is not a new color space, this is exactly the same gammut as RGB. \n
+ * \par
+ * See \ref im_colorhsi.h
+ * \ingroup color */
+
+
+/** Returns I where S is maximum given H (here in radians).
+ * \ingroup hsi */
+float imColorHSI_ImaxS(float h, double cosh, double sinh);
+
+/** Converts from RGB to HSI.
+ * \ingroup hsi */
+void imColorRGB2HSI(float r, float g, float b, float *h, float *s, float *i);
+
+/** Converts from RGB (byte) to HSI.
+ * \ingroup hsi */
+void imColorRGB2HSIbyte(unsigned char r, unsigned char g, unsigned char b, float *h, float *s, float *i);
+
+/** Converts from HSI to RGB.
+ * \ingroup hsi */
+void imColorHSI2RGB(float h, float s, float i, float *r, float *g, float *b);
+
+/** Converts from HSI to RGB (byte).
+ * \ingroup hsi */
+void imColorHSI2RGBbyte(float h, float s, float i, unsigned char *r, unsigned char *g, unsigned char *b);
+
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

data/ext/iup-mswin32/include/im_complex.h

@@ -0,0 +1,180 @@
+/** \file
+ * \brief Complex Data Type.
+ *
+ * See Copyright Notice in im_lib.h
+ */
+
+#ifndef __IM_COMPLEX_H
+#define __IM_COMPLEX_H
+
+#include "im_math.h"
+
+/** \defgroup cpx Complex Numbers
+ * \par
+ * See \ref im_complex.h
+ * \ingroup util
+ */
+
+/** \brief Complex Float Data Type  
+ *         
+ * \par
+ * Complex class using two floats, one for real part, one for the imaginary part.
+ * \par
+ * It is not a complete complex class, we just implement constructors inside the class.
+ * All the other operators and functions are external to the class.
+ * \ingroup cpx */
+class imcfloat
+{
+public:
+	float real;  ///< Real part.
+	float imag;  ///< Imaginary part.
+
+  ///	Default Constructor (0,0).
+	imcfloat():real(0), imag(0) {}
+
+  ///	Constructor from (real, imag)
+	imcfloat(const float& r, const float& i):real(r),imag(i) {}
+
+  ///	Constructor from (real)
+	imcfloat(const float& r):real(r),imag(0) {}
+};
+
+/** \addtogroup cpx
+ * Complex numbers operators.
+ * @{ 
+ */
+
+inline int operator <= (const imcfloat& C1, const imcfloat& C2)
+{
+  return ((C1.real <= C2.real) && (C1.imag <= C2.imag));
+}
+
+inline int operator <= (const imcfloat& C, const float& F)
+{
+  return ((F <= C.real) && (0 <= C.imag));
+}
+
+inline int operator < (const imcfloat& C1, const imcfloat& C2)
+{
+  return ((C1.real < C2.real) && (C1.imag < C2.imag));
+}
+
+inline int operator < (const imcfloat& C, const float& F)
+{
+  return ((F < C.real) && (0 < C.imag));
+}
+
+inline int operator > (const imcfloat& C1, const imcfloat& C2)
+{
+  return ((C1.real > C2.real) && (C1.imag > C2.imag));
+}
+
+inline int operator > (const imcfloat& C, const float& F)
+{
+  return ((F > C.real) && (0 > C.imag));
+}
+
+inline imcfloat operator + (const imcfloat& C1, const imcfloat& C2)
+{
+  return imcfloat(C1.real + C2.real, C1.imag + C2.imag);
+}
+
+inline imcfloat operator += (const imcfloat& C1, const imcfloat& C2)
+{
+  return imcfloat(C1.real + C2.real, C1.imag + C2.imag);
+}
+
+inline imcfloat operator - (const imcfloat& C1, const imcfloat& C2)
+{
+  return imcfloat(C1.real - C2.real, C1.imag - C2.imag);
+}
+
+inline imcfloat operator * (const imcfloat& C1, const imcfloat& C2)
+{
+  return imcfloat(C1.real * C2.real - C1.imag * C2.imag, 
+                        C1.imag * C2.real + C1.real * C2.imag);
+}
+
+inline imcfloat operator / (const imcfloat& C1, const imcfloat& C2)
+{
+  float den = C2.real * C2.real - C2.imag * C2.imag;
+  return imcfloat((C1.real * C2.real + C1.imag * C2.imag) / den, 
+                        (C1.imag * C2.real - C1.real * C2.imag) / den);
+}
+
+inline imcfloat operator / (const imcfloat& C, const float& R)
+{
+  return imcfloat(C.real / R, C.imag / R);
+}
+
+inline imcfloat operator /= (const imcfloat& C, const float& R)
+{
+  return imcfloat(C.real / R, C.imag / R);
+}
+
+inline imcfloat operator * (const imcfloat& C, const float& R)
+{
+  return imcfloat(C.real * R, C.imag * R);
+}
+
+inline int operator == (const imcfloat& C1, const imcfloat& C2)
+{
+  return ((C1.real == C2.real) && (C1.imag == C2.imag));
+}
+
+inline float cpxreal(const imcfloat& C)
+{
+  return C.real;
+}
+
+inline float cpximag(const imcfloat& C)
+{
+  return C.imag;
+}
+
+inline float cpxmag(const imcfloat& C)
+{
+  return sqrtf(C.real*C.real + C.imag*C.imag);
+}
+
+inline float cpxphase(const imcfloat& C)
+{
+  return atan2f(C.real, C.imag);
+}
+
+inline imcfloat cpxconj(const imcfloat& C)
+{
+  return imcfloat(C.real, -C.imag);
+}
+
+inline imcfloat log(const imcfloat& C)
+{
+  return imcfloat(logf(cpxmag(C)), atan2f(C.real, C.imag));
+}
+
+inline imcfloat exp(const imcfloat& C)
+{
+  float mag = expf(C.real);
+  return imcfloat(mag * cosf(C.imag), mag * sinf(C.imag));
+}
+
+inline imcfloat pow(const imcfloat& C1, const imcfloat& C2)
+{
+  return exp(C1 * log(C2));
+}
+
+inline imcfloat sqrt(const imcfloat& C)
+{
+  float mag = sqrtf(sqrtf(C.real*C.real + C.imag*C.imag));
+  float phase = atan2f(C.real, C.imag) / 2;
+  return imcfloat(mag * cosf(phase), mag * sinf(phase));
+}
+
+inline imcfloat cpxpolar(const float& mag, const float& phase)
+{
+  return imcfloat(mag * cosf(phase), mag * sinf(phase));
+}
+
+/** @} */
+
+#endif

data/ext/iup-mswin32/include/im_convert.h

@@ -0,0 +1,142 @@
+/** \file
+ * \brief Image Conversion
+ *
+ * See Copyright Notice in im_lib.h
+ */
+
+#ifndef __IM_CONVERT_H
+#define __IM_CONVERT_H
+
+#include "im_image.h"
+
+#if	defined(__cplusplus)
+extern "C" {
+#endif
+
+                      
+/** \defgroup convert Image Conversion
+ * \par
+ * Converts one type of image into another. Can convert between color modes
+ * and between data types.
+ * \par
+ * See \ref im_convert.h
+ * \ingroup imgclass */
+
+
+/** Complex to real conversions
+ * \ingroup convert */
+enum imComplex2Real 
+{
+  IM_CPX_REAL, 
+  IM_CPX_IMAG, 
+  IM_CPX_MAG, 
+  IM_CPX_PHASE
+};
+
+/** Predefined Gamma factors. Gamma can be any real number.
+ * When gamma<0 use logarithmic, when gamma>0 use exponential.
+ * gamma(x,g) = ((e^(g*x))-1)/(exp(g)-1)
+ * gamma(x,g) = (log((g*x)+1))/(log(g+1))
+ * \ingroup convert */
+enum imGammaFactor
+{
+  IM_GAMMA_LINEAR   = 0,
+  IM_GAMMA_LOGLITE  = -10,
+  IM_GAMMA_LOGHEAVY = -1000,
+  IM_GAMMA_EXPLITE  = 2,
+  IM_GAMMA_EXPHEAVY = 7
+};
+
+/** Predefined Cast Modes
+ * \ingroup convert */
+enum imCastMode
+{
+  IM_CAST_MINMAX, /**< scan for min and max values */
+  IM_CAST_FIXED,  /**< use predefied 0-max values, see \ref color Color Manipulation. */
+  IM_CAST_DIRECT  /**< direct type cast the value. Only byte and ushort will be cropped. */
+};
+
+/** Changes the image data type, using a complex2real conversion, 
+ * a gamma factor, and an abssolute mode (modulus). \n
+ * When demoting the data type the function will scan for min/max values or use fixed values (cast_mode)
+ * to scale the result according to the destiny range. \n
+ * Except complex to real that will use only the complex2real conversion. \n
+ * Images must be of the same size and color mode. \n
+ * Returns IM_ERR_NONE, IM_ERR_DATA or IM_ERR_COUNTER, see also \ref imErrorCodes.
+ * See also \ref imComplex2Real, \ref imGammaFactor and \ref imCastMode.
+ *
+ * \verbatim im.ConvertDataType(src_image: imImage, dst_image: imImage, cpx2real: number, gamma: number, abssolute: boolean, cast_mode: number) -> error: number [in Lua 5] \endverbatim
+ * \verbatim im.ConvertDataTypeNew(image: imImage, data_type: number, cpx2real: number, gamma: number, abssolute: boolean, cast_mode: number) -> error: number, new_image: imImage  [in Lua 5] \endverbatim
+ * \ingroup convert */
+int imConvertDataType(const imImage* src_image, imImage* dst_image, int cpx2real, float gamma, int abssolute, int cast_mode);
+
+/** Converts one color space to another. Images must be of the same size and data type. \n
+ * CMYK can be converted to RGB only, and it is a very simple conversion. \n
+ * All colors can be converted to Binary, the non zero gray values are converted to 1. \n
+ * RGB to Map uses the median cut implementation from the free IJG JPEG software, copyright Thomas G. Lane. \n
+ * Alpha channel is considered and Transparency* attributes are converted to alpha channel. \n
+ * All other color space conversions assume sRGB and CIE definitions. \n
+ * Returns IM_ERR_NONE, IM_ERR_DATA or IM_ERR_COUNTER, see also \ref imErrorCodes.
+ *
+ * \verbatim im.ConvertColorSpace(src_image: imImage, dst_image: imImage) -> error: number [in Lua 5] \endverbatim
+ * \verbatim im.ConvertColorSpaceNew(image: imImage, color_space: number, has_alpha: boolean) -> error: number, new_image: imImage [in Lua 5] \endverbatim
+ * \ingroup convert */
+int imConvertColorSpace(const imImage* src_image, imImage* dst_image);
+
+/** Converts the image to its bitmap equivalent, 
+ * uses \ref imConvertColorSpace and \ref imConvertDataType. \n
+ * Returns IM_ERR_NONE, IM_ERR_DATA or IM_ERR_COUNTER, see also \ref imErrorCodes.
+ * See also \ref imComplex2Real, \ref imGammaFactor and \ref imCastMode. \n
+ * The function im.ConvertToBitmapNew uses the default convertion result from \ref imColorModeToBitmap if color_space is nil.
+ *
+ * \verbatim im.ConvertToBitmap(src_image: imImage, dst_image: imImage, cpx2real: number, gamma: number, abssolute: boolean, cast_mode: number) -> error: number [in Lua 5] \endverbatim
+ * \verbatim im.ConvertToBitmapNew(image: imImage, color_space: number, has_alpha: boolean, cpx2real: number, gamma: number, abssolute: boolean, cast_mode: number) -> error: number, new_image: imImage [in Lua 5] \endverbatim
+ * \ingroup convert */
+int imConvertToBitmap(const imImage* src_image, imImage* dst_image, int cpx2real, float gamma, int abssolute, int cast_mode);
+
+/** Returns an OpenGL compatible data buffer. Also returns the correspondant pixel format. \n
+ * The memory allocated is stored in the attribute "GLDATA" with BYTE type. And it will exists while the image exists. \n
+ * It can be cleared by setting the attribute to NULL. \n
+ * MAP images are converted to RGB, and BINARY images are converted to GRAY.
+ * Alpha channel is considered and Transparency* attributes are converted to alpha channel.
+ * So calculate depth from glformat, not from image depth.
+ *
+ * \verbatim image:GetOpenGLData() -> gldata: userdata, glformat: number [in Lua 5] \endverbatim
+ * \ingroup convert */
+void* imImageGetOpenGLData(const imImage* image, int *glformat);
+
+
+
+/** \defgroup cnvutil Raw Data Conversion Utilities
+ * \par
+ * Utilities for raw data buffers.
+ * \par
+ * See \ref im_convert.h
+ * \ingroup imagerep */
+
+
+/** Changes the packing of the data buffer. Both must have the same depth.
+ * \ingroup cnvutil */
+void imConvertPacking(const void* src_data, void* dst_data, int width, int height, int depth, int data_type, int src_is_packed);
+
+/** Changes in-place a MAP data into a RGB data. The data must have room for the RGB image. \n
+ * depth can be 3 or 4. count=width*height. \n
+ * \ingroup cnvutil */
+void imConvertMapToRGB(unsigned char* data, int count, int depth, int packed, long* palette, int palette_count);
+                       
+
+
+/* Converts a RGB bitmap into a map bitmap using the median cut algorithm.
+ * Used only "im_convertcolor.cpp" implemented in "im_rgb2map.cpp". 
+ * Internal function kept here because of the compatibility module. 
+ * Will not be at the documentation. */
+int imConvertRGB2Map(int width, int height, 
+              unsigned char *red, unsigned char *green, unsigned char *blue, 
+              unsigned char *map, long *palette, int *palette_count);
+
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

data/ext/iup-mswin32/include/im_counter.h

@@ -0,0 +1,69 @@
+/** \file
+ * \brief Processing Counter
+ *
+ * See Copyright Notice in im_lib.h
+ */
+
+#ifndef __IM_COUNTER_H
+#define __IM_COUNTER_H
+
+#if	defined(__cplusplus)
+extern "C" {
+#endif
+
+
+/** \defgroup counter Counter 
+ * \par
+ * Used to notify the application that a step in the loading, saving or processing operation has been performed.
+ * \par
+ * See \ref im_counter.h
+ * \ingroup util */
+
+/** Counter callback, informs the progress of the operation to the client. \n
+ * Text contains a constant string that is NULL during normal counting, a title in the begining of a sequence 
+ * and a message in the begining of a count.
+ * Counter id identifies diferrent counters. \n
+ * Progress in a count reports a value from 0 to 1000. If -1 indicates the start of a sequence of operations, 1001 ends the sequence. \n
+ * If returns 0 the client should abort the operation. \n
+ * If the counter is aborted, the callback will be called one last time at 1001.
+ * \ingroup counter */
+typedef int (*imCounterCallback)(int counter, void* user_data, const char* text, int progress);
+
+/** Changes the counter callback. Returns old callback. \n
+ * User data is changed only if not NULL.
+ * \ingroup counter */
+imCounterCallback imCounterSetCallback(void* user_data, imCounterCallback counter_func);
+
+/** Begins a new count, or a partial-count in a sequence. \n
+ * Calls the callback with "-1" and text=title, if it is at the top level. \n     
+ * This is to be used by the operations. Returns a counter Id.
+ * \ingroup counter */
+int imCounterBegin(const char* title);
+
+/** Ends a count, or a partial-count in a sequence. \n
+ * Calls the callback with "1001", text=null, and releases the counter if it is at top level count. \n
+ * \ingroup counter */
+void imCounterEnd(int counter);
+
+/** Increments a count. Must set the total first. \n
+ * Calls the callback, text=message if it is the first increment for the count. \n
+ * Returns 0 if the callback aborted, 1 if returns normally.
+ * \ingroup counter */
+int imCounterInc(int counter);
+
+/** Set a specific count. Must set the total first. \n
+ * Calls the callback, text=message if it is the first increment for the count. \n
+ * Returns 0 if the callback aborted, 1 if returns normally.
+ * \ingroup counter */
+int imCounterIncTo(int counter, int count);
+
+/** Sets the total increments of a count.
+ * \ingroup counter */
+void imCounterTotal(int counter, int total, const char* message);
+
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif