Lecture 4 Dynamic Memory Allocation and ImageMagick

Transcription

1 Lecture 4 Dynamic Memory Allocation and ImageMagick

2 sizeof 1 #include <iostream> 2 #include <cstdlib> 3 #include <string> 4 int main() 5 { 6 7 std::cout<<"char "<<sizeof(char)<<" Bytes \n"; 8 std::cout<<"char *"<<sizeof(char *)<<" Bytes \n"; 9 10 std::cout<<"int "<<sizeof(int)<<" Bytes \n"; 11 std::cout<<"int *"<<sizeof(int *)<<" Bytes \n"; std::cout<<"float "<<sizeof(float)<<" Bytes \n"; 14 std::cout<<"float *"<<sizeof(float *)<<" Bytes \n"; std::cout<<"double "<<sizeof(double)<<" Bytes \n"; 17 std::cout<<"double *"<<sizeof(double *)<<" Bytes \n"; std::cout<<"void * "<<sizeof(void *)<<" Bytes \n"; std::cout<<"bool "<<sizeof(bool)<<" Bytes \n"; 22 std::cout<<"std::string "<<sizeof(std::string)<<" Bytes \n"; 23 std::cout<<"std::string *"<<sizeof(std::string *)<<" Bytes \n"; std::cout<<"long double "<<sizeof(long double)<<" Bytes \n"; 26 std::cout<<"long double *"<<sizeof(long double *)<<" Bytes \n"; return EXIT_SUCCESS; 30 } The sizeof function returns the size of a data type in bytes It is useful to make code re-locatable from different systems.

3 What do you notice? 1 char 1 Bytes 2 char *4 Bytes 3 int 4 Bytes 4 int *4 Bytes 5 float 4 Bytes 6 float *4 Bytes 7 double 8 Bytes 8 double *4 Bytes 9 void * 4 Bytes 10 bool 1 Bytes 11 std::string 4 Bytes 12 std::string *4 Bytes 13 long double 16 Bytes 14 long double *4 Bytes

4 32 Bit Leopard 64 Bit Ubuntu 1 char 1 Bytes 2 char *4 Bytes 3 int 4 Bytes 4 int *4 Bytes 5 float 4 Bytes 6 float *4 Bytes 7 double 8 Bytes 8 double *4 Bytes 9 void * 4 Bytes 10 bool 1 Bytes 11 std::string 4 Bytes 12 std::string *4 Bytes 13 long double 16 Bytes 14 long double *4 Bytes 1 char 1 Bytes 2 char *8 Bytes 3 int 4 Bytes 4 int *8 Bytes 5 float 4 Bytes 6 float *8 Bytes 7 double 8 Bytes 8 double *8 Bytes 9 void * 8 Bytes 10 bool 1 Bytes 11 std::string 8 Bytes 12 std::string *8 Bytes 13 long double 16 Bytes 14 long double *8 Bytes

5 Dynamic Memory C++ allows for memory to be allocated dynamically using the following keywords new delete These are the equivalent of the C functions malloc and free As the memory is created at run-time we need to use a pointer to specify a reference to the newly created memory The following program demonstrates the allocation and use of some memory

6 1 #include <iostream> 2 #include <stdlib.h> 3 4 int main() 5 { 6 int *pmyarray; 7 int size; 8 std::cout<<"how big an array would you like?\n"; 9 std::cin >>size; 10 // create an int array of size 11 pmyarray = new int[size]; for(int i=0; i<size; ++i) 14 pmyarray[i]=i; for(int i=0; i<size; ++i) 17 std::cout<<pmyarray[i]<<std::endl; // REMEMBER delete the array when finished 20 delete [] pmyarray; 21 return EXIT_SUCCESS; 22 }

7 new new will allocate memory of any type (including classes) but must be used with a pointer to the data type 1 char *pchar = new char[100]; 2 float *pfloat = new float[100]; 3 std::string *pstring = new std::string[100]; once we have used an array we must remove it (no auto garbage collection in C++) so we use delete

8 how they work char *pintarray; pintarray = new int[9] pintarray sizeof(int)*9 delete [] pintarray when new is called lots of internal things happen we need not worry about When the pointer is returned the internal system also remembers the size and type of the data when delete [] is called this is used to help deallocate the memory.

9 1 #include <iostream> 2 #include <cstdlib> 3 4 int main() 5 { 6 // define an array of chars 7 char *array = new char[28]; 8 9 char a; 10 int i; // create the following data structure 13 // \nabcdefghijklmnopqrstuvwxyz\n 14 array[0]='\n'; 15 for(a='a',i=1; a<='z'; ++i,++a) 16 array[i]=a; 17 array[i+1]='\n'; 18 // now grab the address of the 2nd 19 // array element 20 char *index=&array[1]; // and loop thru the data till the \n 23 while(*(index)!='\n') 24 std::cout<< (*(index++))<<" "; 25 std::cout<<"\n"; // now get the end z 28 // and loop till the \n 29 index=&array[26]; 30 while(*(index)!='\n') 31 std::cout<< (*(index--))<<" "; 32 std::cout<<"\n"; delete [] array; 35 return EXIT_SUCCESS; 36 }

10 void * The void * pointer is a special type of pointer which can assume any type To do this we have to use coercion of the data type to force it to a specific type. In C we can use (char *) (int *) etc to do this However C++ has a safer method using the cast functions

11 1 #include <iostream> 2 #include <cstdlib> 3 4 int main() 5 { 6 void *pmem; 7 8 pmem= new int[10]; 9 for(int i=0; i<10; ++i) 10 static_cast<int *>(pmem)[i]=i; 11 for(int i=0; i<10; ++i) 12 std::cout<<static_cast<int *>(pmem)[i]; 13 std::cout<<std::endl; 14 delete [] static_cast<int *>( pmem ); pmem = new float[20]; for(int i=0; i<20; ++i) 19 static_cast<float *>(pmem)[i]=i/2.0; 20 for(int i=0; i<20; ++i) 21 std::cout<<static_cast<float *>(pmem)[i]<<" "; 22 std::cout<<std::endl; 23 delete [] static_cast<float *>( pmem ); // create an array of strings 26 pmem = new std::string[3]; 27 static_cast<std::string *>(pmem)[0]="hello"; 28 static_cast<std::string *>(pmem)[1]=" void "; 29 static_cast<std::string *>(pmem)[2]=" pointers\n "; std::cout<<static_cast<std::string *>(pmem)[0]; 32 std::cout<<static_cast<std::string *>(pmem)[1]; 33 std::cout<<static_cast<std::string *>(pmem)[2]; 34 delete [] static_cast<std::string *>(pmem); 35 return EXIT_SUCCESS; 36 } Hello void pointers

12 static_cast<>() The static_cast<>() function takes two arguments <> is the type you wish to convert to () is the variable to cast to the type. This is equivalent to the C (char *) type coercion but much safer for C++ programs

13 3196 Width 2634 Height Each Pixel channel is a range from (char) pixel Each pixel has 3 channels (RGB) Therefore we have (3196*2634)*3*sizeof(char) bytes bytes of data Red Green Blue

14 Creating Images Using dynamic memory allocation we can create an array for an RGB image. The easiest way to do this is as follows Create an array based on the Width, Height and Number of Pixels in the Image depth Loop through these and fill in the pixels for each RGB Component Write to some image file format Free the array Most of the steps for this are simple but the saving of the image file relies on another library

15 ImageMagick / Magick++ Magick++ provides a simple C++ API to the ImageMagick image processing library which supports reading and writing a huge number of image formats as well as supporting a broad spectrum of traditional image processing operations. Magick++ provides access to most of the features available from the C API but in a simple object-oriented and well-documented framework. For More details look at the following url : The simplest operation with the Magick++ Library is the dumping of an array to an image file. This will be used in the following example

16 1 #include <iostream> 2 #include <Magick++.h> 3 #include <iostream> 4 #include <math.h> 5 #include <cstdlib> 6 7 // define widht and height of image 8 const int WIDTH=720; 9 const int HEIGHT=576; int main(void) 12 { 13 // allocate and array of char for image 14 // where data is packed in RGB format where 0=no intensity 15 // 255 = full intensity 16 char *image = new char [WIDTH*HEIGHT*3*sizeof(char)]; 17 // index into our image array 18 unsigned long int index=0; 19 // now loop for width and height of image and fill in 20 for(int y=0; y<height; ++y) 21 { 22 for(int x=0; x<width; ++x) 23 { 24 // set red channel to full 25 image[index]=255; 26 // G&B to off 27 image[index+1]=0; 28 image[index+2]=0; 29 // now skip to next RGB block 30 index+=3; 31 } // end of width loop 32 } // end of height loop 33 // now create an image data block 34 Magick::Image output(width,height,"rgb",magick::charpixel,image); 35 // set the output image depth to 16 bit 36 output.depth(16); 37 // write the file 38 output.write("test.tiff"); 39 // delete the image data. 40 delete [] image; 41 return EXIT_SUCCESS; 42 } include the image magick headers allocate space for image data Loop to create image Write image to file

17 Building 1 ####################################################################### 2 # sourcefiles is the list of the files used for the library 3 # we use the Scons Split function to seperate them for the build 4 ####################################################################### 5 6 sourcefiles = Split("""ImageGen.cpp""") 7 8 ####################################################################### 9 # PROGRAM is the name of the executable we wish to create 10 ####################################################################### PROGRAM='ImageGen' ####################################################################### 15 # build an environment to set the build flags 16 ####################################################################### env = Environment( 20 CC='g++', 21 CCFLAGS='-g -Wall' 22 ) ########################################################################### 25 # ParseConfig is a cool function which runs a config program and adds the 26 # flags to the build 27 # in this case we run Magick++-config and scons does the rest 28 ########################################################################### env.parseconfig( 'Magick++-config --cppflags --ldflags --libs') ########################################################################### 34 # and finally build the program 35 ########################################################################### env.program(program,sourcefiles)

18 Why not use char[][]? You will notice that the array used for the image data is a char [] You may think it would be easier to use a two dimensional array for x,y co-ordinates However we will see in various examples this is not the case. It doesn t take much code to allow use to set individual pixels in a single char [] array.

19 Setting Individual Pixels We can set individual pixels by accessing the memory data based on x,y co-ordinates We then set the block of 3 pixels for each R,G,B values The following code does this 1 void SetPixel(char *Data,unsigned int x,unsigned int y, char R,char G, char B) 2 { 3 unsigned int index=(y*width*3)+x*3; 4 Data[index]=R; 5 Data[index+1]=G; 6 Data[index+2]=B; 7 }

20 Setting Background Colour Once the SetPixel function is generated we can use it to set the background colour 1 void SetBGColour(char *Data,char r, char g, char b) 2 { 3 for(unsigned int y=0; y<height; ++y) 4 for(unsigned int x=0; x<width; ++x) 5 SetPixel(Data,x,y,r,g,b); 6 }

21 Exercise Using the previous example as a template create a sequence of frames to make the animation of a red line crossing from left to right The line should be in the center of the screen and have a height of 4 pixels. Each frame output should advance the line by 1 pixel in the x direction. To view the animation we will use the fcheck utility which needs the file names to be in the following format Name.###.tif where ### is a zero padded frame number.

22 Creating Sequences of names The easiest way to create a sequence is a loop an the sprintf C function However it relies on a static array which can cause problems if the string created gets larger than the array 1 char name[100]; 2 3 for(int frame=0; frame<10; ++i) 4 { 5 sprintf(name,"test.%04d.tiff",frame); }

23 boost++ Boost provides free peer-reviewed portable C++ source libraries. It has libraries that work well with the C++ Standard Library. Boost libraries are intended to be widely useful, and usable across a broad spectrum of applications. Some of the elements of Boost will be in the new C ++0x standard when released.

24 boost::format You will notice from the example below we have no static arrays We only use the string data type and the boost::format function Format specifiers (%04d %f etc) are still the same. 1 std::string fname; 2 // outer loop for frames 3 for (unsigned int frame=0; frame<width; ++frame) 4 { 5 fname=(boost::str(boost::format("test.%04d.tiff") % frame)); 6 std::cout <<"doing frame "<<fname<<std::endl; 7 }

25 1 #include <iostream> 2 #include <Magick++.h> 3 #include <iostream> 4 #include <math.h> 5 #include <stdlib.h> 6 #include <boost/format.hpp> 7 8 const unsigned int WIDTH=100; 9 const unsigned int HEIGHT=100; int main(void) 12 { 13 char *image = new char [WIDTH*HEIGHT*3]; 14 std::string fname; 15 // outer loop for frames 16 for (unsigned int frame=0; frame<width; ++frame) 17 { 18 // the below is the same as sprintf(fname,"test.%d.tiff",frame); 19 fname=(boost::str(boost::format("test.%04d.tiff") % frame)); 20 std::cout <<"doing frame "<<fname<<std::endl; SetBGColour(image,255,255,255); for(unsigned int y=(height/2)-2; y<(height/2)+2; y++) 25 for(unsigned int x=0; x<frame; x++) 26 SetPixel(image,x,y,255,0,0); Magick::Image output(width,height,"rgb",magick::charpixel,image); 30 output.depth(16); 31 output.write(fname.c_str()); }// end frame loop 34 delete [] image; 35 return EXIT_SUCCESS; 36 }

26 The % (modulus) Operator The remainder operator (%) returns the integer remainder of the result of dividing the first operand with the second For example the value of 7 % 2 is 1 / /

27 The % (modulus) Operator The magnitude of m % n must always be lest than the division n The table below show some of the results of the % operator 1 3 % 5 = 3 5 % 3 = % 5 = 4 5 % 4 = % 5 = 0 15 % 5 = % 5 = 1 15 % 6 = % 5 = 2 15 % -7 (varies 1 under gcc) 6 8 % 5 = 3 15 % 0 is undefined (core dump under gcc)

28 1 #include <Magick++.h> 2 #include <cmath> 3 #include <cstdlib> 4 5 const int WIDTH=201; 6 const int HEIGHT=201; 7 const int OFFSET=80; 8 9 int main() 10 { 11 char *image = new char [WIDTH*HEIGHT*3]; 12 unsigned long int index=0; 13 for(int y=0; y<height; y++) 14 { 15 for(int x=0; x<width; x++) 16 { 17 if( (y%20) && (x%20)) 18 { 19 image[index]=255; 20 image[index+1]=0; 21 image[index+2]=0; 22 } 23 else 24 { 25 image[index]=255; 26 image[index+1]=255; 27 image[index+2]=255; 28 } 29 index+=3; 30 }// end width loop 31 } // end height loop Magick::Image output(width,height,"rgb",magick::charpixel,image); 34 output.depth(16); 35 output.write("test.tiff"); delete [] image; 38 return EXIT_SUCCESS; 39 } x%40 y %40 x%20 y %10 x%100 y %2

29 Fake Sphere The following function is used to describe a sphere 1 // code modified from Computer Graphics with OpenGL F.S. Hill 2 3 // get the value on the sphere at co-ord s,t 4 5 float FakeSphere(float s, float t) 6 { 7 float r=sqrt((s-0.5)*(s-0.5)+(t-0.5)*(t-0.5)); 8 if(r<0.5) 9 return 1-r/0.5; 10 else 11 return 1.0; 12 }

30 Fake Sphere This function will work for any value of s and t in the range of 0-1. The values will then range from 1.0 outside the sphere to black edges and then to white in the centre as shown on the image above Using the template code add this function and draw a sphere.

31 int main(void) 4 { 5 // create an array of floats for our image data 6 float *image = new float [WIDTH*HEIGHT*3]; 7 // index into our data structure 8 unsigned long int index=0; 9 // Our step in texture space from 0-1 within the width of the image 10 float Sstep=1.0/WIDTH; 11 float Tstep=1.0/HEIGHT; 12 // actual S,T value for texture space 13 float S=0.0; 14 float T=0.0; 15 // loop for the image dimensions 16 for(int y=0; y<height; y++) 17 { 18 for(int x=0; x<width; x++) 19 { 20 // fill the data values with sphere values 21 image[index]=fakesphere(s,t); 22 image[index+1]=fakesphere(s,t); 23 image[index+2]=fakesphere(s,t); 24 // update the S value 25 S+=Sstep; 26 // step to the next image index 27 index+=3; 28 } 29 // update the T value 30 T+=Tstep; 31 // reset S to the left hand value 32 S=0.0; 33 } 34 // write out image and close 35 Magick::Image output(width,height,"rgb",magick::floatpixel,image); 36 output.depth(16); 37 output.write("test.tiff"); 38 delete [] image; 39 return EXIT_SUCCESS; 40 }

32 Repeating Patterns As the previous function works from 0-1 if we make the Sphere values range from 0-8 and only use the part after the decimal point we can create a pattern as shown above To do this we use the C++ function fmod The fmod() functions computes the floating-point remainder of x/ y. Specifically, the functions return the value x-i*y, for some integer i such that, if y is non-zero, the result has the same sign as x and magnitude less than the magnitude of y. So to make the value of T repeat 8 times we would use 1 float ss=fmod(s*8,1); 2 float tt=fmod(t*8,1);

33 int main(void) 4 { 5 // create an array of floats for our image data 6 float *image = new float [WIDTH*HEIGHT*3]; 7 // index into our data structure 8 unsigned long int index=0; 9 // Our step in texture space from 0-1 within the width of the image 10 float Sstep=1.0/WIDTH; 11 float Tstep=1.0/HEIGHT; 12 // actual S,T value for texture space 13 float S=0.0; 14 float T=0.0; 15 // used for the repeat values 16 float ss,tt; 17 // loop for the image dimensions 18 for(int y=0; y<height; y++) 19 { 20 for(int x=0; x<width; x++) 21 { 22 ss=fmod(s*40,1); 23 tt=fmod(t*40,1); // fill the data values with sphere values 26 image[index]=fakesphere(ss,tt); 27 image[index+1]=fakesphere(ss,tt); 28 image[index+2]=fakesphere(ss,tt); 29 // update the S value 30 S+=Sstep; 31 // step to the next image index 32 index+=3; 33 } 34 // update the T value 35 T+=Tstep; 36 // reset S to the left hand value 37 S=0.0; 38 } 39 // write out image and close 40 Magick::Image output(width,height,"rgb",magick::floatpixel,image); 41 output.depth(16); 42 output.write("test.tiff"); 43 delete [] image; 44 return EXIT_SUCCESS; 45 } ss=fmod(s*2,1); tt=fmod(t*4,1); ss=fmod(s*4,2); tt=fmod(t*4,2); ss=fmod(s*6,1); tt=fmod(t*6,1); ss=fmod(s*16,4); tt=fmod(t*16,4);

34 Random Numbers The standard C Library has a simple Pseudo Random number generator function called rand(); The rand() function computes a sequence of pseudo-random integers in the range of 0 to RAND_MAX (as defined by the header file <cstdlib>). It produces the same set of numbers each time unless we set a seed value using the srand() function

35 1 #ifndef RNG_H 2 #define RNG_H 3 4 #include <cmath> 5 #include <cstdlib> 6 7 class RNG 8 { 9 public : static int HALF_RAND=(RAND_MAX / 2); 12 /*! returns a random number between +/ \returns a random number between +/- 1 */ 14 static float RandomNum(void) 15 { 16 int rn; 17 rn = rand(); 18 return ((float)(rn - HALF_RAND) / (float)half_rand); 19 } 20 /*! returns a random number between +/- MaxVal 21 \param Real MaxVal the value to set for the max rand num 22 \returns a random number between +/- 1 */ 23 static float RandomNum(float MaxVal) 24 { 25 return MaxVal * RandomNum(); 26 } 27 /*! returns a positive random number between 0 and MaxVal 28 \param Real MaxVal the value to set for the max rand num 29 \returns a random number between 0 and MaxVal */ 30 static float RandomPosNum(float MaxVal) 31 { 32 return (MaxVal *rand()/(rand_max+1.0f)); 33 } /*! set the random seed */ static void SetSeed(void) 38 { 39 srand((unsigned int)time(null)); 40 } }; #endif

36 1 int main(void) 2 { 3 float *image = new float [WIDTH*HEIGHT*3]; 4 5 int x,y; 6 float r,g,b; 7 8 for(unsigned int i=0; i<500000; ++i) 9 { 10 x=rng::randomposnum(width); 11 y=rng::randomposnum(height); 12 r=rng::randomposnum(1.0); 13 g=rng::randomposnum(1.0); 14 b=rng::randomposnum(1.0); SetPixel(image,x,y,r,g,b); 17 } Magick::Image output(width,height,"rgb",magick::floatpixel,image); 20 output.depth(16); 21 output.write("test.tiff"); delete [] image; 25 return EXIT_SUCCESS; 26 }

37 Drawing Lines To draw a line in raster space we need to specify two points (x1,y1,x2,y2) We then need to determine which elements in the raster are to be set One of the earliest and most simple method to do this is the Bresenham's line algorithm The algorithm determines which points in an n-dimensional raster should be plotted in order to form a close approximation to a straight line between two given points. It uses only integer addition, subtraction and bit shifting all of which are very cheap operations in standard computer architectures. It is one of the earliest algorithms developed in the field of computer graphics.

38 Pseudo Code 1 function line(x0, x1, y0, y1) 2 boolean steep := abs(y1 - y0) > abs(x1 - x0) 3 if steep then 4 swap(x0, y0) 5 swap(x1, y1) 6 if x0 > x1 then 7 swap(x0, x1) 8 swap(y0, y1) 9 int deltax := x1 - x0 10 int deltay := abs(y1 - y0) 11 int error := deltax / 2 12 int ystep 13 int y := y0 14 if y0 < y1 then ystep := 1 else ystep := for x from x0 to x1 16 if steep then plot(y,x) else plot(x,y) 17 error := error - deltay 18 if error < 0 then 19 y := y + ystep 20 error := error + deltax

39 1 #include <algorithm> 2 3 void DrawLine(float *Data,int x0, int y0, int x1, int y1,float r, float g, float b) 4 { 5 bool steep = abs(y1 - y0) > abs(x1 - x0); 6 if(steep) 7 { 8 std::swap(x0,y0); 9 std::swap(x1,y1); 10 } 11 if( x0> x1) 12 { 13 std::swap(x0,x1); 14 std::swap(x1,y1); 15 } 16 int deltax = x1-x0; 17 int deltay = abs(y1-y0); 18 int error = deltax/2; 19 int ystep; 20 int y = y0; 21 if(y0 < y1) 22 ystep=1; 23 else 24 ystep=-1; 25 for(int x=x0; x<x1; ++x) 26 { 27 if(steep) 28 SetPixel(Data,y,x,r,g,b); 29 else 30 SetPixel(Data,x,y,r,g,b); 31 error-=deltay; 32 if(error <0) 33 { 34 y+=ystep; 35 error+=deltax; 36 } 37 } 38 } Implementation use the C++ swap method from <algorithm>

40 Drawing Circles The midpoint circle algorithm is an algorithm used to determine the points needed for drawing a circle. The algorithm is a variant of Bresenham's line algorithm, and is thus sometimes known as Bresenham's circle algorithm, although not actually invented by Bresenham.

41 Implementation 1 void DrawCircle(float *Data,int x0, int y0, int radius,float r, float g, float b) 2 { 3 int f = 1 - radius; 4 int ddf_x = 1; 5 int ddf_y = -2 * radius; 6 int x = 0; 7 int y = radius; 8 9 SetPixel(Data,x0, y0 + radius,r,g,b); 10 SetPixel(Data,x0, y0 - radius,r,g,b); 11 SetPixel(Data,x0 + radius, y0,r,g,b); 12 SetPixel(Data,x0 - radius, y0,r,g,b); while(x < y) 15 { 16 if(f >= 0) 17 { 18 y--; 19 ddf_y += 2; 20 f += ddf_y; 21 } 22 x++; 23 ddf_x += 2; 24 f += ddf_x; 25 SetPixel(Data,x0 + x, y0 + y,r,g,b); 26 SetPixel(Data,x0 - x, y0 + y,r,g,b); 27 SetPixel(Data,x0 + x, y0 - y,r,g,b); 28 SetPixel(Data,x0 - x, y0 - y,r,g,b); 29 SetPixel(Data,x0 + y, y0 + x,r,g,b); 30 SetPixel(Data,x0 - y, y0 + x,r,g,b); 31 SetPixel(Data,x0 + y, y0 - x,r,g,b); 32 SetPixel(Data,x0 - y, y0 - x,r,g,b); } 35 } As this function can produce values outside the range of the raster structure we need to modify the SetPixel function 1 void SetPixel(float *Data, int x,int y, float R,float G, float B) 2 { 3 if(x>=width y>=height) 4 return; 5 unsigned int index=(y*width*3)+x*3; 6 Data[index]=R; 7 Data[index+1]=G; 8 Data[index+2]=B; 9 }

42 References format.html Graphics Gems" (book 1) 1990, page 99 s_line_algorithm bresenh.html