Image Capture Overview

make_uname.bat

int imVideoCaptureDeviceCount(void)
+const char* imVideoCaptureDeviceDesc(int device)
int imVideoCaptureReloadDevices(void)
imVideoCapture* vc = imVideoCaptureCreate(); 
+if (!imVideoCaptureConnect(vc, 0))
+  return;
+
+int width, height;
+imVideoCaptureGetImageSize(vc, &width, &height);
+
+// initializes the data pointer
+void* data = malloc(width*height*3);
+
+imVideoCaptureOneFrame(vc, data, IM_RGB);
+imVideoCaptureDestroy(vc);
CVSROOT=:pserver:anonymous@cvs.luaforge.net:/cvsroot/imtoolkit
\mylibs\
+        iup\
+            bin\
+            html\
+            include\
+            lib\Linux26
+            lib\vc7
+            src
+        cd\
+        im\
+        lua5\
1) "-I/mylibs/iup/include" to find include files
+2) "-L/mylibs/iup/lib/Linux26" to find library files
+3) "-liup" to specify the library files
\mylibs\
+        im\
+        lua5.1\
im -> libjpeg (included)
+   -> libpng  (included)
+   -> libtiff (included)
+   -> zlib    (included)
+   -> liblzf  (included)
+   -> libexif (included)
+im_jp2 -> im
+       -> libJasper (included)
+im_avi -> im
+       -> vfw32 (system - Windows)
+im_wmv -> im
+       -> wmvcore (system - Windows)
+im_ecw -> im
+       -> NCSEcw (system)
+im_capture -> strmiids (system - Windows)
+im_process -> im
+im_fftw -> im
+        -> fftw (included)
+imlua51 -> im
+        -> lua5.1
+imlua_capture51 -> imlua51
+                -> im_capture
+imlua_fftw51 -> imlua51
+             -> im_fftw
+imlua_process51 -> imlua51
+                -> im_process
#define imcdCanvasPutImage(_canvas, _image, _x, _y, _w, _h, _xmin, _xmax, _ymin, _ymax)     \
+  {                                                                         \
+    if (_image->color_space == IM_RGB)                                      \
+    {                                                                       \
+      if (image->has_alpha)                                                 \
+        cdCanvasPutImageRectRGBA(_canvas, _image->width, _image->height,    \
+                          (unsigned char*)_image->data[0],                  \
+                          (unsigned char*)_image->data[1],                  \
+                          (unsigned char*)_image->data[2],                  \
+                          (unsigned char*)_image->data[3],                  \
+                          _x, _y, _w, _h, _xmin, _xmax, _ymin, _ymax);      \
+      else                                                                  \
+        cdCanvasPutImageRectRGB(_canvas, _image->width, _image->height,     \
+                          (unsigned char*)_image->data[0],                  \
+                          (unsigned char*)_image->data[1],                  \
+                          (unsigned char*)_image->data[2],                  \
+                          _x, _y, _w, _h, _xmin, _xmax, _ymin, _ymax);      \
+    }                                                                       \
+    else                                                                    \
+      cdCanvasPutImageRectMap(_canvas, _image->width, _image->height,       \
+                        (unsigned char*)_image->data[0], _image->palette,   \
+                        _x, _y, _w, _h, _xmin, _xmax, _ymin, _ymax);        \
+  }
           IM             <->  OpenGL
        color_mode             format
+IM_RGB|IM_ALPHA|IM_PACKED  = GL_RGBA               
+IM_RGB|IM_PACKED           = GL_RGB
+IM_GRAY                    = GL_LUMINANCE
+IM_GRAY|IM_ALPHA|IM_PACKED = GL_LUMINANCE_ALPHA
        data_type              type
+IM_BYTE                    = GL_UNSIGNED_BYTE
+IM_BINARY                  = GL_BITMAP
+IM_USHORT                  = GL_UNSIGNED_SHORT
+IM_INT                     = GL_INT
+IM_FLOAT                   = GL_FLOAT
imConvertPacking(image->data[0], gl_data, image->width, image->height, image->depth, image->data_type, 0);
+glPixelStorei(GL_UNPACK_ALIGNMENT, 1); /* data alignment must be 1 */
+
+glDrawPixels(image->width, image->height, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid*)gl_data);
if (imColorSpace(color_mode) == IM_MAP)
+{
+  long palette[256];
+  int palette_count, packed = 1; /* OpenGL uses packed RGB */
+  imFileGetPalette(ifile, palette, &palette_count);
+  imConvertMapToRGB(gl_data, width*height, depth, packed, palette, palette_count);
+}
glPixelStorei(GL_PACK_ALIGNMENT, 1); /* data alignment must be 1 */
+glReadPixels(x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid*)gl_data);
+
+ifile = imFileNew(filename, format, &error);
+error = imFileWriteImageInfo(ifile, width, height, IM_RGB|IM_PACKED, IM_BYTE);
+error = imFileWriteImageData(ifile, gl_data);
+imFileClose(ifile); 
#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+#include <imlua.h>
void main(void)
+{
+  lua_State *L = lua_open();
+
+  luaopen_string(L);
+  luaopen_math(L);
+  luaopen_io(L);  
+
+  imlua_open(L);
+
+  lua_dofile("myprog.lua");
+  
+  lua_close(L);
+}
local imlua_open = package.loadlib("imlua51.dll", "imlua_open")
+imlua_open()
"./lib?51.so;"    [in UNIX]
+
+".\\?51.dll;"     [in Windows]
imXxx  -> im.Xxx
+IM_XXX -> im.XXX
+imFileXXX(ifile,... -> ifile:XXX(...
+imImageXXX(image,... -> image:XXX(...
void imProcessFlip(const imImage* src_image, imImage* dst_image);
void DoProc(imbyte* data, int width, int height)
+{
+  for (int y = 0; y < height; y++)
+  {
+    for (int x = 0; x < width; x++)
+    {
+      // Do something
+      int offset = y * width + x;
+
+      data[offset] = 0;
+    }
+  }
+}
+
+void SampleProc(imImage* image)
+{
+  // a loop for all the color planes
+  for (int d = 0; d < image->depth; d++)
+  {
+    // Notice that the same operation may be used to process each color component
+    DoProc((imbyte*)image->data[d], image->width, image->height);
+  }
+}
template <class T> 
+void DoProc2(const T* src_data, T* dst_data, int count)
+{
+  for (int i = 0; i < count; i++)
+  {
+    src_data[i] = dst_data[i];
+    
+    // or a more low level approach
+    
+    *src_data++ = *dst_data++;
+  }
+}
+
+// This is a sample that do not depends on the spatial distribution of the data.
+// It uses data[0], the pointer where all depths depends on.
+
+void SampleProc2(const imImage* src_image, imImage* dst_image)
+{
+  int total_count = src_image->count * src_image->depth; 
+  switch(src_image->data_type)
+  {
+  case IM_BYTE:
+    DoProc((imbyte*)src_image->data[0], (imbyte*)dst_image->data[0], total_count);
+    break; 
+  case IM_USHORT:
+    DoProc((imushort*)src_image->data[0], (imushort*)dst_image->data[0], total_count);
+    break; 
+  case IM_INT: 
+    DoProc((int*)src_image->data[0], (int*)dst_image->data[0], total_count);
+    break; 
+  case IM_FLOAT: 
+    DoProc((float*)src_image->data[0], (float*)dst_image->data[0], total_count);
+    break; 
+  case IM_CFLOAT: 
+    DoProc((imcfloat*)src_image->data[0], (imcfloat*)dst_image->data[0], total_count);
+    break;
+  }
+}
int counter = imCounterBegin("Process Test 1");
+imCounterTotal(counter, count_steps, "Processing");
+
+for (int i = 0; i < count_steps; i++)
+{
+  // Do something
+
+
+  if (!imCounterInc(counter))
+    return IM_ERR_COUNTER;
+}
+
+imCounterEnd(counter);
imProcessCanny(in,out,stddev)
+imProcessHysteresisThreshold(in,out,low,high)
+
+imProcessHoughLines(in,out)
+imProcessLocalMaxThreshold(in,out,size,min)
+
+imProcessHoughLinesDraw(in1,in2,out)
gray = imImageCreate(width, height, IM_GRAY, IM_BYTE);
+binary = imImageCreate(width, height, IM_BINARY, IM_BYTE);
+binary2 = imImageClone(binary);
+
+rhomax = sqrt(width*width +height*height)/2;
+hough_height=2*rhomax+1;
+hough = imImageCreate(180, hough_height, IM_GRAY, IM_INT);
+hough_binary = imImageCreate(180, hough_height, IM_BINARY, IM_BYTE);
+
+imConvertColorSpace(rgb, gray);
+
+// very important step, the quality of the detected lines are highly dependent on
+// the quality of the binary image
+// Using a simple threshold like in here maybe not a good solution for your image
+imProcessPercentThreshold(gray, binary, percent=50); 
+
+// eliminates unwanted objects, depending on the quality of the threshold
+// this step can be skiped
+imProcessBinMorphClose(binary, binary2, 3, 1); 
+imProcessPrune(binary2, binary, 4, size=100, 0);
+
+// Is there any holes in the objects?
+// Holes also have borders...
+imProcessFillHoles(binary, binary2, 4);
+
+// leave only the object borders
+imProcessPerimeterLine(binary2, binary);  
+
+// here you should have near only the lines you want to detect.
+// if there are more or less lines that you want redo the previous steps
+
+imProcessHoughLines(binary, hough);
+imProcessLocalMaxThreshold(hough, hough_binary, 7, 100);
+
+// this is optional, it will draw the results
+imProcessHoughLinesDraw(gray,hough_binary,draw_hough); 
Y = a * X + b
+cos(theta) * X + sin(theta) * Y = rho
+
+where:
+  X = x - width/2
+  Y = y - height/2
+
+because the origin of the transform is in the center of the image
theta = 0 .. 179  (horizontal coordinate of the hough space)
+rho = -rhomax .. rhomax    (vertical coordinate of the hough space, 
+                            vertically centered in the image)
+
+where:
+    rhomax = sqrt(width*width + height*height) /2            (width and height of the original image)
theta = xi;
+rho = yi - rhomax;
+
+then:
+
+a = -cos(theta)/sin(theta);
+b = (rho + (width/2)*cos(theta) + (height/2)*sin(theta))/sin(theta);
imProcessSliceThreshold(in, out, level1, level2)
+imProcessPrune(in, out, connect, size1, size2)
+imProcessFillHoles(in, out, connect)
+imAnalyzeFindRegions(in, out, connect)
+imAnalyzeMeasureArea(in, area)
+imAnalyzeMeasurePerimeter(in, perim)
int width, height, color_mode, data_type;
+int size = imImageDataSize(width, height, color_mode, data_type);
+void* buffer = malloc(size);
float* idata = (float*)buffer;
float value;
+if (is_packed) 
+value = idata[y*width*depth + x*depth + d]
+else
+value = idata[d*width*height + y*width + x]
int width, height, color_space, data_type, palette_count;
+long *palette;
+void* buffer
+
+imImage* image;
+
+image = imImageCreate(width, height, color_space, data_type) 
+image = imImageInit(width, height, color_space, data_type, buffer, palette, palette_count) 
+image = imImageDuplicate(image) 
+image = imImageClone(image) 
count = width*height;
+unsigned char* idata = (unsigned char*)image->data[0];
+for (int i = 0; i < count; i++)
+{
+  idata[i] = 255;
+}
for (int d = 0; d < image->depth; d++)
+{
+  unsigned char* idata = (unsigned char*)image->data[d];
+
+  for (int y = 0; y < height; y++)
+  {
+    for (int x = 0; x < width; x++)
+    {
+      int offset = y * width + x; 
+
+      idata[offset] = 255;
+    }
+  }
+}
IM Info
+  File Name:
+    exif_test.tif
+  File Size: 9.00 Mb
+  Format: TIFF - Tagged Image File Format
+  Compression: NONE
+  Image Count: 1
+  Image #0
+    Width: 2048
+    Height: 1536
+    Color Space: RGB
+      Has Alpha: No
+      Is Packed: Yes
+      Is Top Down: Yes
+    Data Type: byte
+    Data Size: 9.00 Mb
+    Attributes:
+      YResolution: 72.00
+      XResolution: 72.00
+      DateTime: 2004:01:14 11:30:11
+      Make: SONY
+      ResolutionUnit: DPI
+      Model: CD MAVICA
+      Photometric: 2
RRRRRRRRRRRRRRRRGGGGGGGGGGGGGGGGBBBBBBBBBBBBBBBB - for non packed components
+0   1   2   3   0   1   2   3   0   1   2   3
RGBRGBRGBRGBRGBRGBRGBRGBRGBRGBRGBRGBRGBRGBRGBRGB - for packed components
+0           1           2           3
IM Info
+  File Name:
+    exif_test.tif
+  File Size: 9.00 Mb
+  Format: TIFF - Tagged Image File Format
+  Compression: NONE
+  Image Count: 1
+  Image #0
+    Width: 2048
+    Height: 1536
+    Color Space: RGB
+      Has Alpha: No
+      Is Packed: Yes
+      Is Top Down: Yes
+    Data Type: byte
+    Data Size: 9.00 Mb
+    Attributes:
+      YResolution: 72.00
+      XResolution: 72.00
+      DateTime: 2004:01:14 11:30:11
+      Make: SONY
+      ResolutionUnit: DPI
+      Model: CD MAVICA
+      Photometric: 2
require"imlua"
+local ifile, error = im.FileOpen(file_name)
+local format, compression, image_count = ifile:GetInfo()
+local format_desc = im.FormatInfo(format)
+for i = 1, image_count do
+   local width, height, color_mode, data_type, error = ifile:ReadImageInfo(i)
+end
+ifile:Close()    
require"imlua"
+
+local image = im.FileImageLoad(filename)
+
+local r = image[0]
+local g = image[1]
+local b = image[2]
+
+for row = 0, image:Height() - 1, 10 do
+	for column = 0, image:Width() - 1, 10 do
+		r[row][column] = 0
+		g[row][column] = 0
+		b[row][column] = 0
+	end
+end
+
+image:Save("edit.bmp", "BMP")
require"imlua"
+require"imlua_process"
+local image = im.ImageCreate(500, 500, im.RGB, im.BYTE)
+im.ProcessRenderRandomNoise(image) 
+image:Save("noise.tif", "TIFF") 
require"imlua"
+require"cdlua"
+require"imlua_cd"
+
+local image = im.ImageCreate(500, 500, im.RGB, im.BYTE)
+local canvas = image:cdCreateCanvas()  -- Creates a CD_IMAGERGB canvas
+
+canvas:Activate()  
+canvas:Clear()
+canvas:Font("Times", cd.BOLD, 24)
+canvas:Text(100, 100, "Test")
+canvas:Line(0,0,100,100)
+canvas:KillCanvas(canvas)
+
+image:Save("new.bmp", "BMP")  
char format[10], compression[10];
+int error, image_count;
+int width, height, color_mode, data_type;
+void* data;
+
+imFile* ifile = imFileOpen("test.tif", &error);
+if (error != IM_ERR_NONE) 
+  // handle the error
+
+imFileGetInfo(ifile, format, compression, &image_count);
+
+for (i = 0; i < image_count, i++)
+{
+  error = imFileReadImageInfo(ifile, i, &width, &height, &color_mode, &data_type);
+  if (error != IM_ERR_NONE) 
+    // handle the error
+
+  // prepare data
+
+  error = imFileReadImageData(ifile, data, 0, -1); // no bitmap convertion, use original color mode flags
+  if (error != IM_ERR_NONE) 
+    // handle the error
+
+  // store data somewhere
+}
+
+imFileClose(ifile); 
imFile* ifile = imFileOpen(file_name, &error);
+
+imFileReadImageInfo(ifile, 0, &width, &height, &color_mode, &data_type);
+
+imFileReadImageData(ifile, data, 0, -1);
+
+imFileClose(ifile); 
imFile* ifile = imFileOpen(file_name, &error);
+ 
+imImage* image = imFileLoadImage(ifile, 0, &error);
// or use imFileLoadBitmap to force a bitmap conversion
+
+imFileClose(ifile);
imImage* image = imFileImageLoad(file_name, 0, &error);
int error, width, height;
+void *data;
+
+imFile* ifile = imFileNew("test.tif", "TIFF", &error);
+if (error != IM_ERR_NONE) 
+  // handle the error
+
+for (i = 0; i < image_count, i++)
+{
+  error = imFileWriteImageInfo(ifile, width, height, IM_RGB, IM_BYTE);
+  if (error != IM_ERR_NONE) 
+    // handle the error
+
+  error = imFileWriteImageData(ifile, data);
+  if (error != IM_ERR_NONE) 
+    // handle the error
+}
+
+imFileClose(ifile); 
imFile* ifile = imFileNew(file_name, format, &error);
+
+error = imFileWriteImageInfo(ifile, width, height, color_mode, data_type);
+
+error = imFileWriteImageData(ifile, data);
+
+imFileClose(ifile); 
imFile* ifile = imFileNew(file_name, format, &error);
+
+error = imFileSaveImage(ifile, image);
+
+imFileClose(ifile);
error = imFileImageSave(file_name, format, image);
static void imIupErrorMessage(int error, int interactive)
+{
+  char* lang = IupGetLanguage();
+  char *msg, *title;
+  if (strcmp(lang, "ENGLISH")==0)
+  {
+    title = "Error";
+    switch (error)
+    {
+    case IM_ERR_OPEN:
+      msg = "Error Opening File.";
+      break;
+    case IM_ERR_MEM:
+      msg = "Insuficient memory.";
+      break;
+    case IM_ERR_ACCESS:
+      msg = "Error Accessing File.";
+      break;
+    case IM_ERR_DATA:
+      msg = "Image type not Suported.";
+      break;
+    case IM_ERR_FORMAT:
+      msg = "Invalid Format.";
+      break;
+    case IM_ERR_COMPRESS:
+      msg = "Invalid or unsupported compression.";
+      break;
+    default:
+      msg = "Unknown Error.";
+    }
+  }
+  else
+  {
+    title = "Erro";
+    switch (error)
+    {
+    case IM_ERR_OPEN:
+      msg = "Erro Abrindo Arquivo.";
+      break;
+    case IM_ERR_MEM:
+      msg = "Memória Insuficiente.";
+      break;
+    case IM_ERR_ACCESS:
+      msg = "Erro Acessando Arquivo.";
+      break;
+    case IM_ERR_DATA:
+      msg = "Tipo de Imagem não Suportado.";
+      break;
+    case IM_ERR_FORMAT:
+      msg = "Formato Inválido.";
+      break;
+    case IM_ERR_COMPRESS:
+      msg = "Compressão Inválida ou não Suportada.";
+      break;
+    default:
+      msg = "Erro Desconhecido.";
+    }
+  }
+
+  if (interactive)
+    IupMessage(title, msg);
+  else
+    printf("%s: %s", title, msg);
+}
+
int old_mode = imBinFileSetCurrentModule(IM_MEMFILE);
+
+imBinMemoryFileName MemFileName; // This structure must exists 
+    while the file remains open.

+    MemFileName.buffer = NULL; // Let the library initializes the buffer, 

+                           
+    // but it must be freed the the application, free(MemFileName.buffer) 
+    MemFileName.size = 1024; // The initial size

+    MemFileName.reallocate = 1.5; // The reallocation will increase 50% the 
+    buffer.

+                              
+    // This is used only when writing with a variable buffer.

+                              
+    // Use 0 to fix the buffer size.
+
+int error;

+    imFile* ifile = imFileNew((const char*)&MemFileName, "GIF", &error); 
+
+imBinFileSetCurrentModule(old_mode); // The mode needs to be active 
+    only for the imFileOpen/imFileNew call.
+
+if (error != IM_ERR_NONE) ....
IM Info
+  File Name:
+    exif_test.tif
+  File Size: 9.00 Mb
+  Format: TIFF - Tagged Image File Format
+  Compression: NONE
+  Image Count: 1
+  Image #0
+    Width: 2048
+    Height: 1536
+    Color Space: RGB
+      Has Alpha: No
+      Is Packed: Yes
+      Is Top Down: Yes
+    Data Type: byte
+    Data Size: 9.00 Mb
+    Attributes:
+      YResolution: 72.00
+      XResolution: 72.00
+      DateTime: 2004:01:14 11:30:11
+      Make: SONY
+      ResolutionUnit: DPI
+      Model: CD MAVICA
+      Photometric: 2
bitmap_test BITMAP bitmap_test.bmp
#include <windows.h>
+#include <im.h>
+#include <im_dib.h>
+
+HBITMAP hBmp = LoadBitmap(hInstance, "bitmap_test");
+imDib* dib = imDibFromHBitmap(hBmp, NULL);
+imImage* image imDibToImage(dib);
+imDibDestroy(dib);
+

AIX43	IBM AIX 4.3 (ppc) / gcc 2.95 / Motif 2.1 +
AIX43cc	IBM AIX 4.3 (ppc) / cc 4.4 / Motif 2.1
AIX43_64	IBM AIX 4.3 (ppc) (64 bits libraries) / cc 4.4 / Motif 2.1
IRIX65	SGI IRIX 6.5 (mips) / gcc 3.0 / Motif 2.1 +
IRIX6465	SGI IRIX 6.5 (mips) / gcc 3.3 / Motif 1.2
IRIX6465cc	SGI IRIX 6.5 (mips) / cc MIPSpro 7.4 / Motif 1.2 +
IRIX6465_64	SGI IRIX 6.5 (mips) (64 bits libraries) / cc MIPSpro 7.4 / Motif 1.2
Linux24	Red Hat 7.3 (x86) / Kernel 2.4 / gcc 2.95 / Open Motif 2.1 +
Linux24g3	CentOS 3.9 (x86) / Kernel 2.4 / gcc 3.2 / Open Motif 2.2 + ³
Linux24g3_64	Red Hat E.L. WS 3 (x64) (64 bits libraries) / Kernel 2.4 / gcc 3.2 / Open Motif + 2.2 ³
Linux26	CentOS 4.5 (x86) / Kernel 2.6 / gcc 3.4 / Open Motif 2.2 + ³
Linux26_64	CentOS 4.5 (x64) / Kernel 2.6 / gcc 3.4 / Open Motif 2.2 + ³
Linux26g4	Ubuntu 6.06 (x86) / Kernel 2.6 / gcc 4.0 / Open Motif + 2.2 ³
Linux26g4_64	Ubuntu 6.10 (x64) / Kernel 2.6 / gcc 4.1 / + OpenMotif 2.2 ³
Linux26g4ppc	Ubuntu 7.10 (ppc) / Kernel 2.6 / gcc 4.1 / Open Motif 2.2 + ³
Linux26_ia64	Red Hat E.L. AS 4 (ia64) / Kernel 2.6 / gcc 3.4 / + Open Motif 2.2 ³
SunOS57	Sun Solaris 7 (sparc) / gcc 2.95 / Motif 2.1 +
SunOS57cc	Sun Solaris 7 (sparc) / cc 5.2 (Sun WorkShop 6 update 1) / Motif 2.1 +
SunOS57_64	Sun Solaris 7 (sparc) (64 bits libraries) / cc 5.2 (Sun WorkShop 6 update 1) / Motif 2.1 +
SunOS58	Sun Solaris 8 (sparc) / gcc 3.4 / Motif 2.1 +
SunOS58cc	Sun Solaris 8 (sparc) / Sun WorkShop 6 update 2 C++ 5.3 / Motif 2.1 +
SunOS58_64	Sun Solaris 8 (sparc) / Sun WorkShop 6 update 2 C++ 5.3 / Motif 2.1 +
SunOS510x86	Sun Solaris 10 (x86) / gcc 3.3 / Motif 2.1 +
FreeBSD54	Free BSD 5.4 (x86) / gcc 3.4 / Open Motif 2.2 + ³
HP-UXB11	HP-UX 11 (9000) / HP ANSI C++ B3910B / Motif 2.1
Darwin811	Mac OS X 10.4.11 (ppc) / Darwin Kernel Version 8.11 / gcc 4.0 / + Open Motif 2.1
Darwin811x86	Mac OS X 10.4.11 (x86) / Darwin Kernel Version 8.11 / gcc 4.0 / + Open Motif 2.1
Win32_vc6	Microsoft Visual C++ 6 (static RTL/single thread)
Win32_vc7	Microsoft Visual C++ 7.1 (.NET 2003) (static RTL/single thread) + Also compatible with Microsoft Visual C++ Toolkit 2003 - + http://msdn.microsoft.com/visualc/vctoolkit2003/ + Â¹
Win32_vc8	Microsoft Visual C++ 8.0 (2005) (static RTL/multithread) + Also compatible with Microsoft Visual C++ 2005 Express Edition - + http://msdn.microsoft.com/vstudio/express/visualc/ + Â¹
Win32_vc9	Microsoft Visual C++ 9.0 (2008) (static RTL/multithread) + Also compatible with Microsoft Visual C++ 2008 Express Edition - + http://msdn.microsoft.com/vstudio/express/visualc/ + Â¹
Win32_dll	built using vc6, creates dependency with MSVCRT.DLL + (either other libraries or new applications).
Win32_dll7	built using vc7, creates dependency with MSVCR71.DLL + (either other libraries or new applications).
Win32_dll8	built using vc8, creates dependency with MSVCR80.DLL + (either other libraries or new applications).
Win32_dll9	built using vc9, creates dependency with MSVCR90.DLL + (either other libraries or new applications).
Win64_vc8	Same as Win32_vc8 but for 64-bits + systems using x64 standard.
Win64_vc9	Same as Win32_vc9 but for 64-bits + systems using x64 standard.
Win64_dll8	Same as Win32_dll8 but for 64-bits + systems using x64 standard.
Win64_dll9	Same as Win32_dll9 but for 64-bits + systems using x64 standard.
Win32_gcc3	Cygwin gcc 3.4 (Depends on Cygwin DLL 1.5) - + http://www.cygwin.com/ + Â¹
Win32_cygw15	Same as Win32_gcc3, but using the Cygwin Posix + system
Win32_mingw3	MingW gcc 3.4 - + http://www.mingw.org/ + Â¹ + Also compatible with Dev-C++ - + http://www.bloodshed.net/devcpp.html + Â¹
Win32_mingw4	MingW gcc 4.x (unofficial) - + http://www.develer.com/oss/GccWinBinaries + Â¹
Win32_owc1	Open Watcom 1.5 - + http://www.openwatcom.org/
Win32_bc56	Borland C++ BuilderX 1.0 / Borland C++ 5.6 Compiler - + + http://www.borland.com/products/downloads/download_cbuilderx.html + Â¹,Â² + (the C++ BuilderX IDE can also be configured to use mingw3 or gcc3 versions.) +
Win32_bin	Executables only for Windows NT/2000/XP
Win64_bin	Same as Win32_bin but for 64-bits systems + using the x64 standard
Win32_cygw15_bin	Executables only for Windows NT/2000/XP, but + using the Cygwin Posix system

Image Capture Overview

Capture Guide

Capture Samples

Tecgraf Library License

CVS

Download

Tecgraf/PUC-Rio Library Download Tips

Guide

Libraries Dependencies

History of Changes

Version 3.4 (14/Oct/2008)

Version 3.3 (26/Nov/2007)

Version 3.2 (24/Nov/2006)

Version 3.1 (12/Dez/2005)

Version 3.0.3 (14/Oct/2004)

Version 3.0.2 (25/Aug/2004)

Version 3.0.1 (22/Apr/2004)

Version 3.0 (April 2004)

Version 2.6 (May 2002)

Version 2.5 (August 2001)

Version 2.4 (February 2000)

Version 2.3 (June 1998)

Version 2.2 (November 1997)

Version 2.1 (October 1997)

Version 2.0 (September 1997)

Version 1.1 (June 1996)

Version 1.0 (October 1995)

Project Management:

Lua Binding Guide

Modifications to the API

Garbage Collection

Image Processing Guide

Image Processing Samples

Image Processing Overview

Publications

Image Representation Guide

Image Representation Samples

Image Representation Overview

Width and Height

Color Space

Data Type

Color Mode Flags

Color Components Packaging (IM_PACKED or unpacked)

Alpha Channel (IM_ALPHA or no alpha)

Orientation (IM_TOPDOWN or bottom up)

Examples

Raw Data Buffer

imImage

Complete Samples

im_info

im_copy

proc_fourier

im_view

glut_capture

iupglcap

IMLAB

Lua Samples

Storage Overview

Storage Guide

Error Messages

More Storage Samples

To Do

General

For the Processing library:

Our plans for the future include:

Comparing IM with Other Imaging Toolkits

Comparsion

`im_info`

`im_copy`

`proc_fourier`

`im_view`

`glut_capture`

`iupglcap`

`IMLAB`