TLIB documentation
 

tlPixelArray.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////////
//
//  This file is part of the TLIB computer vision library.
//  Copyright (C) 2003-2008 Sebastien Grange
//  Copyright (C) 2003-2007 VRAI Group, EPFL
//  All rights reserved.
// 
//  This library is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License("GPL") version 2
//  as published by the Free Software Foundation.
// 
//  <http://www.tuyphon.com/tlib>
//
/////////////////////////////////////////////////////////////////////////////////


#ifndef __TLPIXELARRAY_H__
#define __TLPIXELARRAY_H__


#include "tlVision.h"
#include "tlRect.h"


class tlPixelArray : public tlRect
{
protected:  
  int create      (tl_format format, int width, int height);
  int deletePixel ();

public:

  tl_format       format;
  unsigned long   timeStamp;
  int             pixelWidth;
  bool            hr;
  unsigned char   hrShift;
  tlHRPixel*      hrpixel;
  tlPixel*        pixel;


  // constructors
  tlPixelArray  ();
  tlPixelArray  (tl_format format, int width, int height);
  tlPixelArray  (tlPixelArray *pixelArray);
  virtual ~tlPixelArray ();

  // initialization
  int init (tlPixelArray *pixelArray);
  int init (tl_format format, int width, int height);
  int init (int width, int height, int pixelWidth);

  // data access
  int setPixel (int val, int x, int y, int channel=0);
  int setPixel (int val, tlPoint *point, int channel=0);
  int getPixel (int x, int y, int channel=0);
  int getPixel (tlPoint *point, int channel=0);
  
  // copy and format
  int     copy   (tlPixelArray *pixelArray);
  int     copy   (tlPixelArray *pixelArray, tlRect *rect);
  int     copyTo (tlPixelArray *pixelArray);
  int     copyTo (tlPixelArray *pixelArray, tlRect *rect);
  int     toRect (tlRect *rect);
  tlRect* toRect ();

  // scale
  int scale (float factor, int method=TL_SCALE_DECIMATE);
  int scale (int newWidth, int newHeight, int method=TL_SCALE_DECIMATE);
  int scale (float factor, tlPixelArray *dest, int method=TL_SCALE_DECIMATE);
  int scale (int newWidth, int newHeight, tlPixelArray *dest, int method=TL_SCALE_DECIMATE);

  // clear
  int clear (void);
  int clear (tlRect *rect);

  // channel management
  int addChannel    ();
  int remChannel    (int channel);
  int toChannel     (int channel);
  int toChannel     (int channel, tlRect *rect);
  int putChannel    (tlPixel *pixelArray, int channel);
  int putChannel    (tlPixel *pixelArray, tlRect *rect, int channel);
  int putChannel    (tlPixelArray *pixelArray, int channel);
  int putChannel    (tlPixelArray *pixelArray, tlRect *rect, int channel);
  int swapChannels  (int channel1, int channel2);

  // channel management to new images
  int remChannel    (int channel, tlPixelArray *dest);
  int toChannel     (int channel, tlPixelArray *dest);
  int toChannel     (int channel, tlRect *rect, tlPixelArray *dest);
  int putChannel    (tlPixel *pixelArray, int channel, tlPixelArray *dest);
  int putChannel    (tlPixel *pixelArray, tlRect *rect, int channel, tlPixelArray *dest);
  int putChannel    (tlPixelArray *pixelArray, int channel, tlPixelArray *dest);
  int putChannel    (tlPixelArray *pixelArray, tlRect *rect, int channel, tlPixelArray *dest);
  int swapChannels  (int channel1, int channel2, tlPixelArray *dest);

  // format changes
  int toRgb     ();
  int toRgb     (tlRect *rect);
  int toYuv     ();
  int toYuv     (tlRect *rect);
  int toNrg     ();
  int toNrg     (tlRect *rect);
  int toHsi     ();
  int toHsi     (tlRect *rect);
  int toGray    ();
  int toGray    (tlRect *rect);
  int toBin     (int threshold = 1);
  int toBin     (int threshold, tlRect *rect);
  int toBin     (int min, int max);
  int toBin     (int min, int max, tlRect *rect);

  // copy to new images
  int toRgb     (tlPixelArray *dest);
  int toRgb     (tlRect *rect, tlPixelArray *dest);
  int toYuv     (tlPixelArray *dest);
  int toYuv     (tlRect *rect, tlPixelArray *dest);
  int toNrg     (tlPixelArray *dest);
  int toNrg     (tlRect *rect, tlPixelArray *dest);
  int toHsi     (tlPixelArray *dest);
  int toHsi     (tlRect *rect, tlPixelArray *dest);
  int toGray    (tlPixelArray *dest);
  int toGray    (tlRect *rect, tlPixelArray *dest);
  int toBin     (int threshold, tlPixelArray *dest);
  int toBin     (int threshold, tlRect *rect, tlPixelArray *dest);
  int toBin     (int min, int max, tlPixelArray *dest);
  int toBin     (int min, int max, tlRect *rect, tlPixelArray *dest);
  
  // image masking
  int mask (tlRect *rect);
  int mask (tlPixelArray *mask);
  int mask (tlPixelArray *mask, tlRect *rect);
  int mask (tlRect *rect, tlPixelArray *dest);
        int mask (tlPixelArray *mask, tlPixelArray *dest);
  int mask (tlPixelArray *mask, tlRect *rect, tlPixelArray *dest);

  // image subtracting/adding
  int add (tlPixelArray *pixelArray);
  int add (tlPixelArray *pixelArray, tlRect *rect);
  int add (tlPixelArray *pixelArray, tlPixelArray *dest);
  int add (tlPixelArray *pixelArray, tlRect *rect, tlPixelArray *dest);
  int sub (tlPixelArray *pixelArray);
  int sub (tlPixelArray *pixelArray, tlRect *rect);
  int sub (tlPixelArray *pixelArray, tlPixelArray *dest);
  int sub (tlPixelArray *pixelArray, tlRect *rect, tlPixelArray *dest);

  // convolution
  int convolution (char  *kernel,  int kernel_size);
  int convolution (char  *kernel,  int kernel_width, int kernel_height);
  int convolution (float *kernel,  int kernel_size);
  int convolution (float *kernel,  int kernel_width, int kernel_height);
  int convolution (char  *kernel,  int kernel_size,  tlRect *rect);
  int convolution (char  *kernel,  int kernel_width, int kernel_height, tlRect *rect);
  int convolution (float *kernel,  int kernel_size,  tlRect *rect);
  int convolution (float *kernel,  int kernel_width, int kernel_height, tlRect *rect);
  int convolution (char  *xkernel, int xksize, char  *ykernel, int yksize);
  int convolution (char  *xkernel, int xksize, char  *ykernel, int yksize, tlRect *rect);
  int convolution (float *xkernel, int xksize, float *ykernel, int yksize);
  int convolution (float *xkernel, int xksize, float *ykernel, int yksize, tlRect *rect);

  // convolution to a new image
  int convolution (char  *kernel,  int kernel_size,  tlPixelArray *dest);
  int convolution (char  *kernel,  int kernel_width, int kernel_height, tlPixelArray *dest);
  int convolution (float *kernel,  int kernel_size,  tlPixelArray *dest);
  int convolution (float *kernel,  int kernel_width, int kernel_height, tlPixelArray *dest);
  int convolution (char  *kernel,  int kernel_size,  tlRect *rect, tlPixelArray *dest);
  int convolution (char  *kernel,  int kernel_width, int kernel_height, tlRect *rect, tlPixelArray *dest);
  int convolution (float *kernel,  int kernel_size,  tlRect *rect, tlPixelArray *dest);
  int convolution (float *kernel,  int kernel_width, int kernel_height, tlRect *rect, tlPixelArray *dest);
  int convolution (char  *xkernel, int xksize, char  *ykernel, int yksize, tlPixelArray *dest);
  int convolution (char  *xkernel, int xksize, char  *ykernel, int yksize, tlRect *rect, tlPixelArray *dest);
  int convolution (float *xkernel, int xksize, float *ykernel, int yksize, tlPixelArray *dest);
  int convolution (float *xkernel, int xksize, float *ykernel, int yksize, tlRect *rect, tlPixelArray *dest);
  int convolution (float *xkernel, int xksize, float *ykernel, int yksize, tlRect *rect, tlPixelArray *mask, tlPixelArray *dest);

  // filters
  int median (int size);
  int median (int size, tlRect *rect);

  // morph processing
  int erode   (int size);
  int erode   (int size, tlRect *rect);
  int erode   (tlMask *shape);
  int erode   (tlMask *shape, tlRect *rect);
  int dilate  (int size);
  int dilate  (int size, tlRect *rect);
  int dilate  (tlMask *shape);
  int dilate  (tlMask *shape, tlRect *rect);
  int opening (int size);
  int opening (int size, tlRect *rect);
  int opening (tlMask *shape);
  int opening (tlMask *shape, tlRect *rect);
  int closing (int size);
  int closing (int size, tlRect *rect);
  int closing (tlMask *shape);
  int closing (tlMask *shape, tlRect *rect);
  int thin    ();
  int thin    (tlRect *rect);

  // morph processing to a new image
  int erode   (int size, tlPixelArray *dest);
  int erode   (int size, tlRect *rect, tlPixelArray *dest);
  int dilate  (int size, tlPixelArray *dest);
  int dilate  (int size, tlRect *rect, tlPixelArray *dest);
  int opening (int size, tlPixelArray *dest);
  int opening (int size, tlRect *rect, tlPixelArray *dest);
  int closing (int size, tlPixelArray *dest);
  int closing (int size, tlRect *rect, tlPixelArray *dest);
  int thin    (tlPixelArray *dest);
  int thin    (tlRect *rect, tlPixelArray *dest);

  // monochrome filtering
  int filter (int minVal, int maxVal);
  int filter (int minVal, int maxVal, tlRect *rect);
  int filter (int minVal, int maxVal, tlPixelArray *dest);
  int filter (int minVal, int maxVal, tlRect *rect, tlPixelArray *dest);

  // color filtering
  int filter (tlColor *minColor, tlColor *maxColor);
  int filter (tlColor *minColor, tlColor *maxColor, tlRect *rect);
  int filter (tlColor *minColor, tlColor *maxColor, tlPixelArray *dest);
  int filter (tlColor *minColor, tlColor *maxColor, tlRect *rect, tlPixelArray *dest);

  // data
  int getMax      (tlMask *mask, tlPoint *point, int channel = 0);
  int getMin      (tlMask *mask, tlPoint *point, int channel = 0);

  // color extraction
  int getColor    (tlPoint *point, tlColor *color);
  int getColor    (int x, int y, tlColor *color);
  int getColors   (tlColor *minColor, tlColor *maxColor);
  int getColors   (tlColor *minColor, tlColor *maxColor, tlRect *rect);
  int getColorMin (tlColor *minColor);
  int getColorMin (tlColor *minColor, tlRect *rect);
  int getColorMax (tlColor *maxColor);
  int getColorMax (tlColor *maxColor, tlRect *rect);

  // object/shape matching
  int find          (tlObject *object, int confidence, int increment = TL_DEFAULT_INCREMENT);
  int find          (tlObject *object, int confidence, tlRect *rect, int increment = TL_DEFAULT_INCREMENT);
  int findBest      (tlObject *object, int increment = TL_DEFAULT_INCREMENT);
  int findBest      (tlObject *object, tlRect *rect, int increment = TL_DEFAULT_INCREMENT);
  int find          (tlMask   *shape,  int confidence, int increment = TL_DEFAULT_INCREMENT);
  int find          (tlMask   *shape,  int confidence, tlRect *rect, int increment = TL_DEFAULT_INCREMENT);
  int findBest      (tlMask   *shape,  int increment = TL_DEFAULT_INCREMENT);
  int findBest      (tlMask   *shape,  tlRect *rect, int increment = TL_DEFAULT_INCREMENT);
  int findShape     (tlObject *object, int confidence, int increment = TL_DEFAULT_INCREMENT);
  int findShape     (tlObject *object, int confidence, tlRect *rect, int increment = TL_DEFAULT_INCREMENT);
  int findBestShape (tlObject *object, int increment = TL_DEFAULT_INCREMENT);
  int findBestShape (tlObject *object, tlRect *rect, int increment = TL_DEFAULT_INCREMENT);

  // histogram management
  int buildHist (tlHist *hist, int channel=0);
  int buildHist (tlHist *hist, tlRect *rect, int channel=0);
  int buildHist (tlHist *hist, tlMask *mask, int channel=0);
  int buildHist (tlHist *hist, tlMask *mask, tlRect *rect, int channel=0);

  // 2D histogram management
  int buildHist (tlHist2D *hist, int xchannel=0, int ychannel = 1);
  int buildHist (tlHist2D *hist, tlRect *rect, int xchannel=0, int ychannel = 1);
  int buildHist (tlHist2D *hist, tlMask *mask, int xchannel=0, int ychannel = 1);
  int buildHist (tlHist2D *hist, tlMask *mask, tlRect *rect, int xchannel=0, int ychannel = 1);
};


#endif

---

TLIB documentation - generated on 7 May 2008
Please address any questions to seb@tuyphon.com
(C) 2001-2008 - S. Grange
(C) 2001-2007 - VRAI Group, EPFL
All Rights Reserved.