Adding Extra Fonts
The fonts that come with X are quite limited. You may want to install the msttcorefonts package to provide Microsoft TrueType core fonts for use in X.
To install them, run
apt-get install msttcorefonts at the command line as root. If you get an error
E: Couldn't find package msttcorefonts you may need to edit your /etc/apt/sources.list to include the contrib section in your source entry.
1. Download and install the library according to the README file.
2. Copy /usr/local/dislin/dislin.h to /usr/local/include/
3. Copy /usr/local/dislin/libdislin.a to /usr/local/lib/
Now it should work using the following options when compile the program.
> g++ test.cpp -lXt -ldislin -lm
Don't forget the -lXt
Another option is:
> g++ test.cpp /usr/local/dislin/lib/dislin-9.1.a -lm -L/usr/X11R6/lib -lXt
I assumed in the above example that dislin is installed in: /usr/local/dislin/. There is no need to change /etc/profile or set the envionment varibles as the README suggested. Here is a very useful link:
http://people.scs.fsu.edu/~burkardt/cpp_src/dislin/dislin.html
Use dislin:
//
// Specify the format of the output file.
//
// metafl ( "PNG" ); //if want to save as png file
metafl("XWIN"); //this just show the graph on screen
//
// Specify the name of the output graphics file.
//
// setfil ( "dislin_ex01.png" ); //only when you want to save the figure.
disini ( );
pagera ( );
complx ( );
axspos ( 450, 1800 );
axslen ( 2200, 1200 );
name ( "X-axis", "x" );
name ( "Y-axis", "y" );
labdig ( -1, "x" );
ticks ( 10, "xy" );
titlin ( "Demonstration of CURVE", 1 );
titlin ( "SIN(X), COS(X)", 3 );
graf ( 0.0, 360.0, 0.0, 90.0, -1.0, 1.0, -1.0, 0.5 );
title ( );
color ( "red" );
curve ( xray, y1ray, N ); //This is the data transfer part.
color ( "green" );
curve ( xray, y2ray, N );
color ( "fore" );
dash ( );
xaxgit ( );
disfin ( );
There are three basic steps to making an animation. First you need an idea. Next, you need a set of images to run through in individual frames. You can get the images from your digital camera or your scanner or draw them using ImageMagick or the GIMP. Once you have these ready, all you need to do is to put them together into an animation.
Your first animation
A basic animation could just run through several images. You can do this easily using the animate command:
animate image1.gif image2.gif image3.gif
| | |
| A basic animation |
IM displays the images in the order they are listed. Since animate does not save animations, its use is limited to testing. This animation will quickly blur through all the three GIF files.
If you need to pause on an image before moving to the next one, use the -delay switch. It sets the time pause between images in units of 100th of a second:
animate -delay 200 frame1.gif frame2.gif frame3.gif
This sequence of images will spend two seconds on each image. But this command runs the animation just once. It's left to the -loop switch to determine the number of times an animation is to cycle through the frames:
animate -delay 300 frame1.gif frame2.gif frame3.gif -loop 3
This loops the animation three times. -loop 0 loops the animation infinitely.
Placing images
To save an animation we use the convert command, supplying a filename with an appropriate extension. Use
convert -delay 30 frame1.gif frame2.gif frame3.gif \
> -loop 0 playme.gif
This results in an animation, playme.gif, made up of three images looping infinitely.
The animations we have creating so far adjust their size depending upon the size of the constituent images. This can cause havoc if you use them within Web pages. We need to specify a canvas on which to lay out our animation and its constituent images. Let's use a big canvas and place the same image onto it at different places:
convert -delay 0 -size 100x100 xc:green \
> -delay 50 -page +32+62 ball.gif -page +2+35 ball.gif \
> -delay 10 -page +31+2 ball.gif -page +62+32 ball.gif \
> -loop 0 anim.gif
The -page switch places the images at the specified locations. We have also used -delay with every image to set its own pause time.
You can also use the -pause switch to supply the time delay between animation loops:
convert -delay 0 -size 100x100 xc:green \
> -delay 50 -page +32+62 ball.gif -page +2+35 ball.gif \
> -delay 10 -page +31+2 ball.gif -page +62+32 ball.gif \
> -loop 0 -pause 3 anim.gif
The anim.gif image is a green canvas of 100x100 pixels, within which the same image is displayed at multiple locations, each for a specified time, and the sequence repeats after three seconds.
Note that in this animation, new images appear alongside other images. If you want the previous image to disappear before the new one arrives on a clean canvas, use the -dispose switch. It controls the way an image should to be treated after being displayed:
convert -dispose none -delay 0 base.gif \
> -dispose previous -delay 100 \
> -page +32+62 ball.gif -page +2+35 ball.gif \
> -page +31+2 ball.gif -page +62+32 ball.gif \
> -loop 0 animation.gif
| | |
| An animation made with the dispose previous switch |
The most important option of dispose is previous. In an animation, the images before dispose previous become the base image, and the animation returns to this base image after each image is displayed. The dispose in the base image in the example above is thus set to zero. So, base.gif becomes the base image, and the animation returns to it after displaying each image in the sequence. So, the effective order of the animation is: base.gif->big.gif->base.gif->ball.gif->base.gif->
Using convert you can also combine two animations into one file:
convert animation.gif anim.gif combined_anim.gif
This combines the first two GIF files into the last animation in the listed sequence.
Conclusion
ImageMagick is a robust command-line utility capable of doing simple image manipulations like cropping images and changing image formats to drawing various shapes, mosaics, and 3D images to creating animations.
You can create some interesting animations using the commands in this article. You could animate trees swaying in the winds, create ripples in a pond, show cloud movement through the sky, or lip-sync yourself to "Hasta la vista, baby."
Shashank Sharma is a computer science student who loves to write about free and open source software for new users.
in the install file, it is said it is not necessary to install. But it turn out there is something tricky. I just copied the mtl folder to the /usr/local/include, and it doesn't work. The computer complained that std::enum etc. has multiple defination. After I recompile the mtl from source, the problem solved. I don't know exactly what it did when I compile mtl.
I did the following:
1. untar/unzip the file.
2. cd mtl
3. ./configure
4. su to root
5. make install
That is it. And the problem solved. There is something stupid MTL did. I will finally get rid of mtl from my program. It is not a very good library, at least for my code. I will use uBlast or TNT instead.
Frequently we need to treat a function as a first class object in C++. One place these are frequently needed is in numerical methods code. For example a numerical integrator needs to somehow be handed a function to integrate. Some languages do this easily: for example functional languages such as Lisp and Haskell. But C++ is a little weaker in this regard.
float f(float x) {
float y = 2;
float z = 3;
return x*x+y*y+z*z;
}
int main() {
. . .
. . .
integrate(&f,0,1);
. . .
}
But this has some problems. What if we have a function f() of three arguments but want to integrate it along the line y=2, z=3. We need to integrate a helper function
float f(float x,float y,float z) {
return x*x+y*y+z*z;
}
float g(float x) {
return f(x,y,z);
}
float y,z;
int main() {
. . .
. . .
y = 2;
z = 3;
integrate(&g,0,1);
. . .
}
struct Data {
float y,z;
};
float f(float x,void *d) {
Data *p = (Data *)d;
return x*x+p->y*p->y+p->z*p->z;
}
int main() {
. . .
. . .
Data d;
d.y = 2;
d.z = 3;
integrate(f,0,1,&d);
. . .
}
That's pretty horrible even though it's more or less the standard in the C world! In Scheme we can simply build a function on the fly like: (lambda (x) (f x y z)). Can we do something like this in C++?
C++ has a mechanism for handling pointers to functions that hides the fact that you are manipulating pointers to functions: virtual functions. Using these we can have our integrator function call a function whose identity isn't yet determined at runtime. Here's an example:
class Integrand {
public:
float evaluate(float) = 0;
float integrate(float x0,float x1) {
. . .
}
};
class F : public Integrand {
float y,z;
public:
Integrand(float y0,float z0) : y(y0), z(z0) {
}
float evaluate(float x) {
return x*x+y*y+z*z;
}
}
int main() {
. . .
. . .
F f(2,3);
integrate(f,0,1);
. . .
}
That's certainly much more elegant. But unfortunately it's authoritarian. It forces users of the integrate method to derive their functions from Integrand. What if you want to hand the same function to a numerical differentiator? Will you have to write the same function again, only derived from another base class? It would be nice if we could make completely generic function objects that can be used in multiple ways.
This has many great advantages. The function object, f, can be pointer to a function: integrate(sin,0,1) would work for example Or it can be an object with operator() defined. One nice advantage over using virtual functions and function pointers is that it can use knowledge about the function object at runtime to optimise.
template
float integrate(const F &f,float x0,float x1) {
. . .
. . . f(x) . . .
. . .
}
class F {
float y,z;
public:
F(float y0,float z0) : y(y0), z(z0) { }
float operator()(float x) const {
return x*x+y*y+z*z;
}
};
int main() {
. . .
. . .
F f(2,3);
integrate(f,0,1);
. . .
}
What we've actually made here is what computer scientists call a closure [3]. That's an aggregate made of a function and some of its arguments. We can't yet evaluate it because we don't yet know all of its arguments, so it's in a kind of suspended animation waiting for its final arguments.
class F {
float y,z;
public:
F(float y0,float z0) : y(y0), z(z0) { }
template
X operator()(X x) const {
return x*x+y*y+z*z;
}
};
With the help of a template member function F is truly polymorphic. Our integration algorithm can throw any type it likes at F, as long as the methods operator() uses understand. In fact, it's even possible for the integrate function to reconstruct a symbolic representation of the function for a large class of functions by applying operator() to symbolic types that have the arithmetic operators appropriately defined. With a little extra work we can do some real functional programming and even port Haskell code [1] directly to C++..
We have now come a long way from old-fashioned C function pointers.
Defining a Function Object
By Danny Kalev
from the following link:
http://www.inquiry.com/techtips/cpp_pro/10min/10min0100.asp
Although pointers to functions are widely used for implementing function callbacks, C++ offers a significantly superior alternative to them, namely function objects. Function objects (also called "functors") are ordinary class objects that overload the () operator. Thus, syntactically, they behave like ordinary functions.
There are several advantages in using a function object instead of a pointer to function. First, they are more resilient to design changes because the object can be modified internally without changing its external interface. A function object can also have data members that store the result of a previous call. When using ordinary functions, you need to store the result of a previous call in a global or a local static variable. However, global and local static variables have some undesirable characteristics. Finally, compilers can inline a call made through a function object, thereby enhancing performance even further. In contrast, it is nearly impossible to inline a function call made through a pointer.
This solution will show how to define and use a function object that implements a negation operation. The first step consists of declaring an ordinary class and overloading the () operator:
class Negate
{
public:
int operator() (int n) { return -n;}
};
The overloaded () might look a bit confusing because it has two pairs of parentheses. Remember that the first pair is always empty because it serves as the operator's name; the parameter list appears in the second pair of parentheses. Unlike other overloaded operators, whose number of parameters is fixed, the overloaded () operator may take any number of parameters.
Because the built-in negation operator is unary (it takes only a single operand), our overloaded () operator also takes a single parameter. The return type is identical to the parameter's type—int, in our example. The function body is trivial; it simply returns the negated argument.
Using the Function Object
We now define a function named Callback() to test our function object. Callback() takes two arguments: an int and a reference to Negate. Callback() treats neg, the function object, as if it were a function's name:
#include
using std::cout;
void Callback(int n, Negate & neg)
{
int val = neg(n); //1 invoke overloaded ()
cout << val =" neg.operator()(n);" t=""> T operator() (T t) const {return -t;}
};
int main()
{
GenericNegate negate;
cout<<> or less<> to sort() to force a descending or ascending sorting order, respectively:
#include
#include
#include
using namespace std;
int main()
{
vector
//..fill vector
sort(vi.begin(), vi.end(), greater
sort(vi.begin(), vi.end(), less
}
I had gdb problem. It complained "no symbol table", something like that. I don't know exactly how I fixed it. But it seems that after I installed the following packages, it disappeared.
libstdc++2.10-dbg
libstdc++2.10-dev
libstdc++5-3.3-dev
libstdc++6-dbg
libstdc++6-dev
libstdc++6-4.1-dev
then restared kdevelop, now it works! Also make sure that the -g option is in the compile options.
when I used gnuplot, it gives some error. Use the following to check and find the reasons for the error.
> ldd `which gnuplot`
linux-gate.so.1 => (0xffffe000)
libreadline.so.5 => /lib/libreadline.so.5 (0xb7ee5000)
libncurses.so.5 => /lib/libncurses.so.5 (0xb7ea4000)
libz.so.1 => /usr/lib/libz.so.1 (0xb7e8f000)
libstdc++.so.5 => not found
libm.so.6 => /lib/tls/i686/cmov/libm.so.6 (0xb7e6a000)
libgcc_s.so.1 => /lib/libgcc_s.so.1 (0xb7e5f000)
libc.so.6 => /lib/tls/i686/cmov/libc.so.6 (0xb7d2e000)
libdl.so.2 => /lib/tls/i686/cmov/libdl.so.2 (0xb7d2a000)
/lib/ld-linux.so.2 (0xb7f31000)
It is clear that libstdc++.so.5 not found. So need to install it.
Gady Agam
Department of Computer Science
January 27, 2006
Illinois Institute of Technology
cvActionTargetMod(...)
Action = the core functionality (e.g. set, create)
Target = the target image area (e.g. contour, polygon)
Mod = optional modifiers (e.g. argument type)
CV_(S|U|F)C
S = Signed integer
U = Unsigned integer
F = Float
E.g.: CV_8UC1 means an 8-bit unsigned single-channel matrix,
CV_32FC2 means a 32-bit float matrix with two channels.
IPL_DEPTH_(S|U|F)
E.g.: IPL_DEPTH_8U means an 8-bit unsigned image.
IPL_DEPTH_32F means a 32-bit float image.
#include
#include
#include
#include// unnecessary - included in cv.h
g++ hello-world.cpp -o hello-world \
-I /usr/local/include/opencv -L /usr/local/lib \
-lm -lcv -lhighgui -lcvaux
In the project preferences set the path to the OpenCV header files and
the path to the OpenCV library files.
////////////////////////////////////////////////////////////////////////
//
// hello-world.cpp
//
// This is a simple, introductory OpenCV program. The program reads an
// image from a file, inverts it, and displays the result.
//
////////////////////////////////////////////////////////////////////////
#include
#include
#include
#include
#include
int main(int argc, char *argv[])
{
IplImage* img = 0;
int height,width,step,channels;
uchar *data;
int i,j,k;
if(argc<2){>\n\7");
exit(0);
}
// load an image
img=cvLoadImage(argv[1]);
if(!img){
printf("Could not load image file: %s\n",argv[1]);
exit(0);
}
// get the image data
height = img->height;
width = img->width;
step = img->widthStep;
channels = img->nChannels;
data = (uchar *)img->imageData;
printf("Processing a %dx%d image with %d channels\n",height,width,channels);
// create a window
cvNamedWindow("mainWin", CV_WINDOW_AUTOSIZE);
cvMoveWindow("mainWin", 100, 100);
// invert the image
for(i=0;i
cvNamedWindow("win1", CV_WINDOW_AUTOSIZE);
cvMoveWindow("win1", 100, 100); // offset from the UL corner of the screen
IplImage* img=0;
img=cvLoadImage(fileName);
if(!img) printf("Could not load image file: %s\n",fileName);
cvShowImage("win1",img);
Can display a color or grayscale byte/float-image. A byte image is assumed to have values in the range ![$[0..255]$](http://www.cs.iit.edu/%7Eagam/cs512/lect-notes/opencv-intro/img1.png){kind=small}
. A float image is assumed to have values in the range ![$[0..1]$](http://www.cs.iit.edu/%7Eagam/cs512/lect-notes/opencv-intro/img2.png){kind=small}
. A color image is assumed to have data in BGR order.
cvDestroyWindow("win1");
cvResizeWindow("win1",100,100); // new width/heigh in pixels
void mouseHandler(int event, int x, int y, int flags, void* param)
{
switch(event){
case CV_EVENT_LBUTTONDOWN:
if(flags & CV_EVENT_FLAG_CTRLKEY)
printf("Left button down with CTRL pressed\n");
break;
case CV_EVENT_LBUTTONUP:
printf("Left button up\n");
break;
}
}
x,y: pixel coordinates with respect to the UL corner
event: CV_EVENT_LBUTTONDOWN, CV_EVENT_RBUTTONDOWN, CV_EVENT_MBUTTONDOWN,
CV_EVENT_LBUTTONUP, CV_EVENT_RBUTTONUP, CV_EVENT_MBUTTONUP,
CV_EVENT_LBUTTONDBLCLK, CV_EVENT_RBUTTONDBLCLK, CV_EVENT_MBUTTONDBLCLK,
CV_EVENT_MOUSEMOVE:
flags: CV_EVENT_FLAG_CTRLKEY, CV_EVENT_FLAG_SHIFTKEY, CV_EVENT_FLAG_ALTKEY,
CV_EVENT_FLAG_LBUTTON, CV_EVENT_FLAG_RBUTTON, CV_EVENT_FLAG_MBUTTON
mouseParam=5;
cvSetMouseCallback("win1",mouseHandler,&mouseParam);
int key;
key=cvWaitKey(10); // wait 10ms for input
int key;
key=cvWaitKey(0); // wait indefinitely for input
while(1){
key=cvWaitKey(10);
if(key==27) break;
switch(key){
case 'h':
...
break;
case 'i':
...
break;
}
}
void trackbarHandler(int pos)
{
printf("Trackbar position: %d\n",pos);
}
int trackbarVal=25;
int maxVal=100;
cvCreateTrackbar("bar1", "win1", &trackbarVal ,maxVal , trackbarHandler);
int pos = cvGetTrackbarPos("bar1","win1");
cvSetTrackbarPos("bar1", "win1", 25);
IplImage
|-- int nChannels; // Number of color channels (1,2,3,4)
|-- int depth; // Pixel depth in bits:
| // IPL_DEPTH_8U, IPL_DEPTH_8S,
| // IPL_DEPTH_16U,IPL_DEPTH_16S,
| // IPL_DEPTH_32S,IPL_DEPTH_32F,
| // IPL_DEPTH_64F
|-- int width; // image width in pixels
|-- int height; // image height in pixels
|-- char* imageData; // pointer to aligned image data
| // Note that color images are stored in BGR order
|-- int dataOrder; // 0 - interleaved color channels,
| // 1 - separate color channels
| // cvCreateImage can only create interleaved images
|-- int origin; // 0 - top-left origin,
| // 1 - bottom-left origin (Windows bitmaps style)
|-- int widthStep; // size of aligned image row in bytes
|-- int imageSize; // image data size in bytes = height*widthStep
|-- struct _IplROI *roi;// image ROI. when not NULL specifies image
| // region to be processed.
|-- char *imageDataOrigin; // pointer to the unaligned origin of image data
| // (needed for correct image deallocation)
|
|-- int align; // Alignment of image rows: 4 or 8 byte alignment
| // OpenCV ignores this and uses widthStep instead
|-- char colorModel[4]; // Color model - ignored by OpenCV
CvMat // 2D array
|-- int type; // elements type (uchar,short,int,float,double) and flags
|-- int step; // full row length in bytes
|-- int rows, cols; // dimensions
|-- int height, width; // alternative dimensions reference
|-- union data;
|-- uchar* ptr; // data pointer for an unsigned char matrix
|-- short* s; // data pointer for a short matrix
|-- int* i; // data pointer for an integer matrix
|-- float* fl; // data pointer for a float matrix
|-- double* db; // data pointer for a double matrix
CvMatND // N-dimensional array
|-- int type; // elements type (uchar,short,int,float,double) and flags
|-- int dims; // number of array dimensions
|-- union data;
| |-- uchar* ptr; // data pointer for an unsigned char matrix
| |-- short* s; // data pointer for a short matrix
| |-- int* i; // data pointer for an integer matrix
| |-- float* fl; // data pointer for a float matrix
| |-- double* db; // data pointer for a double matrix
|
|-- struct dim[]; // information for each dimension
|-- size; // number of elements in a given dimension
|-- step; // distance between elements in a given dimension
CvSparseMat // SPARSE N-dimensional array
CvArr* // Used only as a function parameter to specify that the
// function accepts arrays of more than a single type, such
// as: IplImage*, CvMat* or even CvSeq*. The particular array
// type is determined at runtime by analyzing the first 4
// bytes of the header of the actual array.
CvScalar
|-- double val[4]; //4D vector
Initializer function:
CvScalar s = cvScalar(double val0, double val1=0, double val2=0, double val3=0);
Example:
CvScalar s = cvScalar(20.0);
s.val[0]=10.0;
Note that the initializer function has the same name as the data structure only starting with a lower case character. It is not a C++ constructor.
CvPoint p = cvPoint(int x, int y);
CvPoint2D32f p = cvPoint2D32f(float x, float y);
CvPoint3D32f p = cvPoint3D32f(float x, float y, float z);
E.g.:
p.x=5.0;
p.y=5.0;
CvSize r = cvSize(int width, int height);
CvSize2D32f r = cvSize2D32f(float width, float height);
CvRect r = cvRect(int x, int y, int width, int height);
IplImage* cvCreateImage(CvSize size, int depth, int channels);
size: cvSize(width,height);
depth: pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16U,
IPL_DEPTH_16S, IPL_DEPTH_32S, IPL_DEPTH_32F, IPL_DEPTH_64F
channels: Number of channels per pixel. Can be 1, 2, 3 or 4. The channels
are interleaved. The usual data layout of a color image is
b0 g0 r0 b1 g1 r1 ...
Examples:
// Allocate a 1-channel byte image
IplImage* img1=cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,1);
// Allocate a 3-channel float image
IplImage* img2=cvCreateImage(cvSize(640,480),IPL_DEPTH_32F,3);
IplImage* img=cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,1);
cvReleaseImage(&img);
IplImage* img1=cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,1);
IplImage* img2;
img2=cvCloneImage(img1);
void cvSetImageROI(IplImage* image, CvRect rect);
void cvResetImageROI(IplImage* image);
vRect cvGetImageROI(const IplImage* image);
The majority of OpenCV functions support ROI.
void cvSetImageCOI(IplImage* image, int coi); // 0=all
int cvGetImageCOI(const IplImage* image);
The majority of OpenCV functions do NOT support COI.
IplImage* img=0;
img=cvLoadImage(fileName);
if(!img) printf("Could not load image file: %s\n",fileName);
Supported image formats: BMP, DIB, JPEG, JPG, JPE, PNG, PBM, PGM, PPM,
SR, RAS, TIFF, TIF
By default, the loaded image is forced to be a 3-channel color image. This default can be modified by using:
img=cvLoadImage(fileName,flag);
flag: >0 the loaded image is forced to be a 3-channel color image
=0 the loaded image is forced to be a 1 channel grayscale image
<0>
if(!cvSaveImage(outFileName,img)) printf("Could not save: %s\n",outFileName);
The output file format is determined based on the file name extension.
-th channel of the pixel at the 
-row and 
-th column. The row index is in the range ![$[0,\mbox{height}-1]$](http://www.cs.iit.edu/%7Eagam/cs512/lect-notes/opencv-intro/img6.png){kind=small}
. The column index is in the range ![$[0,\mbox{width}-1]$](http://www.cs.iit.edu/%7Eagam/cs512/lect-notes/opencv-intro/img7.png){kind=small}
. The channel index is in the range ![$[0,\mbox{nchannels}-1]$](http://www.cs.iit.edu/%7Eagam/cs512/lect-notes/opencv-intro/img8.png){kind=small}
.
IplImage* img=cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,1);
CvScalar s;
s=cvGet2D(img,i,j); // get the (i,j) pixel value
printf("intensity=%f\n",s.val[0]);
s.val[0]=111;
cvSet2D(img,i,j,s); // set the (i,j) pixel value
IplImage* img=cvCreateImage(cvSize(640,480),IPL_DEPTH_32F,3);
CvScalar s;
s=cvGet2D(img,i,j); // get the (i,j) pixel value
printf("B=%f, G=%f, R=%f\n",s.val[0],s.val[1],s.val[2]);
s.val[0]=111;
s.val[1]=111;
s.val[2]=111;
cvSet2D(img,i,j,s); // set the (i,j) pixel value
IplImage* img=cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,1);
((uchar *)(img->imageData + i*img->widthStep))[j]=111;
IplImage* img=cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,3);
((uchar *)(img->imageData + i*img->widthStep))[j*img->nChannels + 0]=111; // B
((uchar *)(img->imageData + i*img->widthStep))[j*img->nChannels + 1]=112; // G
((uchar *)(img->imageData + i*img->widthStep))[j*img->nChannels + 2]=113; // R
IplImage* img=cvCreateImage(cvSize(640,480),IPL_DEPTH_32F,3);
((float *)(img->imageData + i*img->widthStep))[j*img->nChannels + 0]=111; // B
((float *)(img->imageData + i*img->widthStep))[j*img->nChannels + 1]=112; // G
((float *)(img->imageData + i*img->widthStep))[j*img->nChannels + 2]=113; // R
IplImage* img = cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,1);
int height = img->height;
int width = img->width;
int step = img->widthStep/sizeof(uchar);
uchar* data = (uchar *)img->imageData;
data[i*step+j] = 111;
IplImage* img = cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,3);
int height = img->height;
int width = img->width;
int step = img->widthStep/sizeof(uchar);
int channels = img->nChannels;
uchar* data = (uchar *)img->imageData;
data[i*step+j*channels+k] = 111;
IplImage* img = cvCreateImage(cvSize(640,480),IPL_DEPTH_32F,3);
int height = img->height;
int width = img->width;
int step = img->widthStep/sizeof(float);
int channels = img->nChannels;
float * data = (float *)img->imageData;
data[i*step+j*channels+k] = 111;
templateclass Image
{
private:
IplImage* imgp;
public:
Image(IplImage* img=0) {imgp=img;}
~Image(){imgp=0;}
void operator=(IplImage* img) {imgp=img;}
inline T* operator[](const int rowIndx) {
return ((T *)(imgp->imageData + rowIndx*imgp->widthStep));}
};
typedef struct{
unsigned char b,g,r;
} RgbPixel;
typedef struct{
float b,g,r;
} RgbPixelFloat;
typedef ImageRgbImage;
typedef ImageRgbImageFloat;
typedef ImageBwImage;
typedef ImageBwImageFloat;
IplImage* img=cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,1);
BwImage imgA(img);
imgA[i][j] = 111;
IplImage* img=cvCreateImage(cvSize(640,480),IPL_DEPTH_8U,3);
RgbImage imgA(img);
imgA[i][j].b = 111;
imgA[i][j].g = 111;
imgA[i][j].r = 111;
IplImage* img=cvCreateImage(cvSize(640,480),IPL_DEPTH_32F,3);
RgbImageFloat imgA(img);
imgA[i][j].b = 111;
imgA[i][j].g = 111;
imgA[i][j].r = 111;
cvConvertImage(src, dst, flags=0);
src = float/byte grayscale/color image
dst = byte grayscale/color image
flags = CV_CVTIMG_FLIP (flip vertically)
CV_CVTIMG_SWAP_RB (swap the R and B channels)
Using the OpenCV conversion:
cvCvtColor(cimg,gimg,CV_BGR2GRAY); // cimg -> gimg
Using a direct conversion:
for(i=0;iheight;i++) for(j=0;j width;j++)
gimgA[i][j]= (uchar)(cimgA[i][j].b*0.114 +
cimgA[i][j].g*0.587 +
cimgA[i][j].r*0.299);
cvCvtColor(src,dst,code); // src -> dst
code = CV_2 / = RGB, BGR, GRAY, HSV, YCrCb, XYZ, Lab, Luv, HLS
e.g.: CV_BGR2GRAY, CV_BGR2HSV, CV_BGR2Lab
// draw a box with red lines of width 1 between (100,100) and (200,200)
cvRectangle(img, cvPoint(100,100), cvPoint(200,200), cvScalar(255,0,0), 1);
// draw a circle at (100,100) with a radius of 20. Use green lines of width 1
cvCircle(img, cvPoint(100,100), 20, cvScalar(0,255,0), 1);
// draw a green line of width 1 between (100,100) and (200,200)
cvLine(img, cvPoint(100,100), cvPoint(200,200), cvScalar(0,255,0), 1);
CvPoint curve1[]={10,10, 10,100, 100,100, 100,10};
CvPoint curve2[]={30,30, 30,130, 130,130, 130,30, 150,10};
CvPoint* curveArr[2]={curve1, curve2};
int nCurvePts[2]={4,5};
int nCurves=2;
int isCurveClosed=1;
int lineWidth=1;
cvPolyLine(img,curveArr,nCurvePts,nCurves,isCurveClosed,cvScalar(0,255,255),lineWidth);
cvFillPoly(img,curveArr,nCurvePts,nCurves,cvScalar(0,255,255));
CvFont font;
double hScale=1.0;
double vScale=1.0;
int lineWidth=1;
cvInitFont(&font,CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC, hScale,vScale,0,lineWidth);
cvPutText (img,"My comment",cvPoint(200,400), &font, cvScalar(255,255,0));
Other possible fonts:
CV_FONT_HERSHEY_SIMPLEX, CV_FONT_HERSHEY_PLAIN,
CV_FONT_HERSHEY_DUPLEX, CV_FONT_HERSHEY_COMPLEX,
CV_FONT_HERSHEY_TRIPLEX, CV_FONT_HERSHEY_COMPLEX_SMALL,
CV_FONT_HERSHEY_SCRIPT_SIMPLEX, CV_FONT_HERSHEY_SCRIPT_COMPLEX,
CvMat* cvCreateMat(int rows, int cols, int type);
type: Type of the matrix elements. Specified in form
CV_(S|U|F)C . E.g.: CV_8UC1 means an
8-bit unsigned single-channel matrix, CV_32SC2 means a 32-bit signed
matrix with two channels.
Example:
CvMat* M = cvCreateMat(4,4,CV_32FC1);
CvMat* M = cvCreateMat(4,4,CV_32FC1);
cvReleaseMat(&M);
CvMat* M1 = cvCreateMat(4,4,CV_32FC1);
CvMat* M2;
M2=cvCloneMat(M1);
double a[] = { 1, 2, 3, 4,
5, 6, 7, 8,
9, 10, 11, 12 };
CvMat Ma=cvMat(3, 4, CV_64FC1, a);
Alternatively:
CvMat Ma;
cvInitMatHeader(&Ma, 3, 4, CV_64FC1, a);
CvMat* M = cvCreateMat(4,4,CV_32FC1);
cvSetIdentity(M); // does not seem to be working properly
cell of a 2D float matrix.
cvmSet(M,i,j,2.0); // Set M(i,j)
t = cvmGet(M,i,j); // Get M(i,j)
CvMat* M = cvCreateMat(4,4,CV_32FC1);
int n = M->cols;
float *data = M->data.fl;
data[i*n+j] = 3.0;
CvMat* M = cvCreateMat(4,4,CV_32FC1);
int step = M->step/sizeof(float);
float *data = M->data.fl;
(data+i*step)[j] = 3.0;
double a[16];
CvMat Ma = cvMat(3, 4, CV_64FC1, a);
a[i*4+j] = 2.0; // Ma(i,j)=2.0;
CvMat *Ma, *Mb, *Mc;
cvAdd(Ma, Mb, Mc); // Ma+Mb -> Mc
cvSub(Ma, Mb, Mc); // Ma-Mb -> Mc
cvMatMul(Ma, Mb, Mc); // Ma*Mb -> Mc
CvMat *Ma, *Mb, *Mc;
cvMul(Ma, Mb, Mc); // Ma.*Mb -> Mc
cvDiv(Ma, Mb, Mc); // Ma./Mb -> Mc
cvAddS(Ma, cvScalar(-10.0), Mc); // Ma.-10 -> Mc
double va[] = {1, 2, 3};
double vb[] = {0, 0, 1};
double vc[3];
CvMat Va=cvMat(3, 1, CV_64FC1, va);
CvMat Vb=cvMat(3, 1, CV_64FC1, vb);
CvMat Vc=cvMat(3, 1, CV_64FC1, vc);
double res=cvDotProduct(&Va,&Vb); // dot product: Va . Vb -> res
cvCrossProduct(&Va, &Vb, &Vc); // cross product: Va x Vb -> Vc
end{verbatim}
Note that Va, Vb, Vc, must be 3 element vectors in a cross product.
CvMat *Ma, *Mb;
cvTranspose(Ma, Mb); // transpose(Ma) -> Mb (cannot transpose onto self)
CvScalar t = cvTrace(Ma); // trace(Ma) -> t.val[0]
double d = cvDet(Ma); // det(Ma) -> d
cvInvert(Ma, Mb); // inv(Ma) -> Mb
CvMat* A = cvCreateMat(3,3,CV_32FC1);
CvMat* x = cvCreateMat(3,1,CV_32FC1);
CvMat* b = cvCreateMat(3,1,CV_32FC1);
cvSolve(&A, &b, &x); // solve (Ax=b) for x
CvMat* A = cvCreateMat(3,3,CV_32FC1);
CvMat* E = cvCreateMat(3,3,CV_32FC1);
CvMat* l = cvCreateMat(3,1,CV_32FC1);
cvEigenVV(&A, &E, &l); // l = eigenvalues of A (descending order)
// E = corresponding eigenvectors (rows)
CvMat* A = cvCreateMat(3,3,CV_32FC1);
CvMat* U = cvCreateMat(3,3,CV_32FC1);
CvMat* D = cvCreateMat(3,3,CV_32FC1);
CvMat* V = cvCreateMat(3,3,CV_32FC1);
cvSVD(A, D, U, V, CV_SVD_U_T|CV_SVD_V_T); // A = U D V^T
The flags cause U and V to be returned transposed (does not work well without the transpose flags).
CvCapture* capture = cvCaptureFromCAM(0); // capture from video device #0
CvCapture* capture = cvCaptureFromAVI("infile.avi");
IplImage* img = 0;
if(!cvGrabFrame(capture)){ // capture a frame
printf("Could not grab a frame\n\7");
exit(0);
}
img=cvRetrieveFrame(capture); // retrieve the captured frame
To obtain images from several cameras simultaneously, first grab an image from each camera. Retrieve the captured images after the grabbing is complete.
cvReleaseCapture(&capture);
Note that the image captured by the device is allocated/released by the capture function. There is no need to release it explicitly.
cvQueryFrame(capture); // this call is necessary to get correct
// capture properties
int frameH = (int) cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT);
int frameW = (int) cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH);
int fps = (int) cvGetCaptureProperty(capture, CV_CAP_PROP_FPS);
int numFrames = (int) cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_COUNT);
The total frame count is relevant for video files only. It does not seem to be working properly.
float posMsec = cvGetCaptureProperty(capture, CV_CAP_PROP_POS_MSEC);
int posFrames = (int) cvGetCaptureProperty(capture, CV_CAP_PROP_POS_FRAMES);
float posRatio = cvGetCaptureProperty(capture, CV_CAP_PROP_POS_AVI_RATIO);
Get the position of the captured frame in [msec] with respect to the first frame, or get its index where the first frame starts with an index of 0. The relative position (ratio) is 0 in the first frame and 1 in the last frame. This ratio is valid only for capturing images from a file.
// start capturing from a relative position of 0.9 of a video file
cvSetCaptureProperty(capture, CV_CAP_PROP_POS_AVI_RATIO, (double)0.9);
This only applies for capturing from a file. It does not seem to be working properly.
CvVideoWriter *writer = 0;
int isColor = 1;
int fps = 25; // or 30
int frameW = 640; // 744 for firewire cameras
int frameH = 480; // 480 for firewire cameras
writer=cvCreateVideoWriter("out.avi",CV_FOURCC('P','I','M','1'),
fps,cvSize(frameW,frameH),isColor);
Other possible codec codes:
CV_FOURCC('P','I','M','1') = MPEG-1 codec
CV_FOURCC('M','J','P','G') = motion-jpeg codec (does not work well)
CV_FOURCC('M', 'P', '4', '2') = MPEG-4.2 codec
CV_FOURCC('D', 'I', 'V', '3') = MPEG-4.3 codec
CV_FOURCC('D', 'I', 'V', 'X') = MPEG-4 codec
CV_FOURCC('U', '2', '6', '3') = H263 codec
CV_FOURCC('I', '2', '6', '3') = H263I codec
CV_FOURCC('F', 'L', 'V', '1') = FLV1 codec
A codec code of -1 will open a codec selection window (in windows).
IplImage* img = 0;
int nFrames = 50;
for(i=0;i
To view the captured frames during capture, add the following in the loop:
cvShowImage("mainWin", img);
key=cvWaitKey(20); // wait 20 ms
Note that without the 20[msec] delay the captured sequence is not displayed properly.
cvReleaseVideoWriter(&writer);
These are my notes concerning the installation of OpenCV from CVS on Ubuntu Edgy. While I’ll try to be helpful if you have problems, I’m not responsible for blowing up your system.
The charade:
Check out the OpenCV code from cvs:
cvs -d:pserver:anonymous@opencvlibrary.cvs.sourceforge.net:/cvsroot/opencvlibrary login
cvs -z3 -d:pserver:anonymous@opencvlibrary.cvs.sourceforge.net:/cvsroot/opencvlibrary co -P opencv
Then make sure pkg-config and g++ are installed:
sudo apt-get install g++ pkg-config
At this point, you should be able to configure and install opencv, but it probably won’t find some of the libraries it needs to work with video and certain image formats. To get all the functionality of OpenCV, I installed the following packages (Some of these are in the multiverse repositories. Go here to find out how to add more repositories):
sudo apt-get install libgtk2.0-dev libavcodec-dev libavformat-dev libjpeg62-dev libtiff4-dev
Now you can run:
cd opencv && ./configure
Check to make sure all of the fancy features you want show up as enabled. The packages we installed earlier make my configuration show up something like so:
General configuration =============================================
Compiler: g++
CXXFLAGS: -Wall -fno-rtti -pipe -O3 -g -march=i686 -ffast-math -fomit-frame-pointer
Install path: /usr/local
HighGUI configuration =============================================
Windowing system --------------
Use Carbon / Mac OS X: no
Use gtk+ 2.x: yes
Use gthread: yes
Image I/O ---------------------
Use libjpeg: yes
Use zlib: yes
Use libpng: yes
Use libtiff: yes
Use libjasper: no
Use libIlmImf: no
Video I/O ---------------------
Use QuickTime / Mac OS X: no
Use xine: no
Use ffmpeg: yes
Use dc1394 & raw1394: yes
Use v4l: yes
Use v4l2: yes
Wrappers for other languages =========================================
SWIG
Python no
Additional build settings ============================================
Build demo apps yes
Now run make ...
If everything looks good, we can now compile and install OpenCV:
make && sudo make install && sudo ldconfig
You may need to run the following command if /usr/local isn’t in your library search path (make sure you trust users who have write access to /usr/local/lib):
sudo sh -c 'echo "/usr/local/lib" >> /etc/ld.so.conf && ldconfig'
Instead, some guides may instruct you to change the LD_LIBRARY_PATH environment variable, but this is not the best way to get your programs to work. Modifying this variable is generally used as a hack to get things working in the moment, but it should not be used as a permanent solution, as it poses security problems. This means that you shouldn’t try setting this variable in any startup scripts… See this page about shared libraries.
Now you can start writing programs which employ the functionality of OpenCV. The best way learn how to do this is by looking at the sample applications. You can compile the sample applications by doing the following:
cd samples/c
chmod u+x build_all.sh
./build_all.sh
Now you can run the sample apps just like any other executable:
./ProgramName --ProgramOptions
Please comment if you find problems or have suggestions.
Troubleshooting:
If you get an error like the following one after running your application, then you didn’t correctly add /usr/local/lib to the library search path. Go back and do it correctly…
./ProgramName: error while loading shared libraries:
libcxcore.so.1: cannot open shared object file: No such file or directory
Links:
http://www.hci.iastate.edu/575x/doku.php
The wiki for a class using OpenCV. There are examples, tutorials, problems, and students’ solutions all open to the public.
http://opencvlibrary.sourceforge.net
The official OpenCV wiki.
dwww is very good. It will search the documents in the system (not a search engine) and make it very easy to find the help or manuals.
In /etc/apt/, edit a file apt.conf if it doesn't exist. In this file add the following:
Dir::Cache::archives "the/location/you/want/" ;
do not forget ;
In the director you want you must have similar lay out of directory. for example
/home/user/var/cache/apt/archives/
in the above directory you must have partial(director) also.
You can use the following to make the directory:
mkdir -p /home/user/var/cache/apt/archives/partial/
Then your apt.conf can be the following:
Dir::Cache::archives "/home/user/var/cache/apt/archives/";
Another way is:
aptitude -o Dir::Cache::archives "/home/user/var/cache/apt/archives/"
I did not try this one, though it is supposed to work.