paint.c

Dev c++, opencv, image segmentation and paint type image generation

  
  hsival.hue = h;
  hsival.saturation = s;
  hsival.intensity = i;    
  
  return hsival;     
}       

//hsi to rgb conversion
struct rgb hsi2rgb(struct hsi hsival)
{
  struct rgb rgbval;      
  double h = hsival.hue;
  double s = hsival.saturation;
  int i = hsival.intensity;
  int r;
  int g;
  int b;
  
  if(h >= 0 && h <= 2*M_PI/3)
  {
       b = i*(1-s);
       r = i*(1+(s*cos(h))/cos((M_PI/3)-h));
       g = 3*i - r - b;
  }
  else if(h >= 2*M_PI/3 && h <= 4*M_PI/3)
  {
       h = h - 2*M_PI/3;
       r = i*(1-s);
       g = i*(1+(s*cos(h))/cos((M_PI/3)-h));
       b = 3*i - r - g;
  }
  else 
  {
       h = h - 4*M_PI/3;
       g = i*(1-s);
       b = i*(1+(s*cos(h))/cos((M_PI/3)-h));
       r = 3*i - g - b;
  }
  
  rgbval.red = r;
  rgbval.green = g;
  rgbval.blue = b;
  
  return rgbval;
}


//Queue implementation
int qinsert(node **front,node **rear, struct xy item)
{
    int ret = 0;
    node *newnode; 
    newnode=(node*)malloc(sizeof(node));
    newnode->next=NULL;
    newnode->data = item;
    if(*front==NULL && *rear==NULL)
    {
        *front=newnode;
        *rear=newnode;
        ret = 1;
    }
    else
    {
        (*rear)->next=newnode;
        *rear=newnode;
        ret = 1;
    }
    return ret;
}

struct xy qdelete(node **front,node **rear)
{
    node *delnode;      /* Node to be deleted */
    struct xy item;
    if((*front)==NULL && (*rear)==NULL)
        printf("\nQueue is empty to delete any element\n");
    else
    {
        if(size(*front)==1)
        {                  
                           delnode=*front;
        item = delnode->data;
        (*front)=(*front)->next;
                           *front=NULL;
                           *rear=NULL;
                           
                           }
                           else {
                                delnode=*front;
        item = delnode->data;
        (*front)=(*front)->next;
        }
        free(delnode);
    }
    return item;
}

int size(node *front)
{
    int ret=0;
    while(front!=NULL)
    {
        front=front->next;
        ret++;
    }
    return ret;
}

//Queue implementation ends here



//Segmentation and rendering 
IplImage* segmentation(IplImage* img)
{
 int height,width,step,channels;
 uchar *data, *data1;
 int i = 0, j = 0, r, g, b, x1, y1;
 
 height    = img->height;
 width     = img->width;
 step      = img->widthStep;
 channels = img->nChannels;
 data      = (uchar *)img->imageData;
 char visited[height][width];
 int segNo[height][width];
 int thresholdInt[height][width];
 char intensity[height][width];
 char colb[height][width];
 char colg[height][width];
 char colr[height][width];
 
 
  for(y1=0;y1<height;y1++) {
      for(x1=0;x1<width;x1++) {
          
          intensity[y1][x1] = (data[y1*step+x1*channels+0] + 
                                  data[y1*step+x1*channels+1] + 
                                     data[y1*step+x1*channels+2])/3;
          visited[y1][x1] = 0; //not visited
          
      }
   }
   int seg = 1;
   struct xy initialPoint;
   initialPoint.x = height/2;
   initialPoint.y = width/2;
   qinsert(&f1, &r1, initialPoint);
   visited[height/2][width/2] = 1;
   thresholdInt[height/2][width/2] = intensity[height/2][width/2];
   segNo[height/2][width/2] = seg;
   colb[height/2][width/2] = data[(height*step/2)+(width*channels/2)+0];
   colg[height/2][width/2] = data[(height*step/2)+(width*channels/2)+1];
   colr[height/2][width/2] = data[(height*step/2)+(width*channels/2)+2];
   
   
   while(size(f1) != 0)
   {
       int i1 = 0, j1 = 0, tempInt;
       struct xy out = qdelete(&f1, &r1);
       i = out.x;
       j = out.y; 
       int segTemp = segNo[i][j];
       tempInt = thresholdInt[i][j];
//this for loop updates all data structures by BFS         
       for(i1 = i-1; i1 <= i+1; i1++)
       {
          for(j1 = j-1; j1 <= j+1; j1++)
          {
              if(j1 >= 0 && i1 >= 0 && i1 < height && j1 < width)
              {  
                  if(visited[i1][j1] == 0)
                  {
                      struct xy tempPoint;
                      tempPoint.x = i1;
                      tempPoint.y = j1;            
                      qinsert(&f1, &r1, tempPoint);
                      visited[i1][j1] = 1;   
                      if(intensity[i1][j1] >= tempInt-30 && intensity[i1][j1] <= tempInt+30)
                      {
                           segNo[i1][j1] = segTemp;
                           thresholdInt[i1][j1] = tempInt;
                           colb[i1][j1] = data[i*step+j*channels+0];
                           colg[i1][j1] = data[i*step+j*channels+1];
                           colr[i1][j1] = data[i*step+j*channels+2];
                           
                      }  
                      else
                      {
                           segNo[i1][j1] = seg++;
                           thresholdInt[i1][j1] = intensity[i][j];
                      }
                  }
              }
          }
       }    
   }   
   
  IplImage* paintImage;  
  paintImage = cvCreateImage(cvSize(width, height), img->depth, channels);
  data1     = (uchar *)paintImage->imageData; 
      
  x1 = 0;
  y1 = 0;
  for(y1 = 0; y1 < height; y1++)
  {
     for(x1 = 0; x1 < width; x1++)
     {
        data1[y1*step+x1*channels+0] = colb[y1][x1]; 
        data1[y1*step+x1*channels+1] = colg[y1][x1];
        data1[y1*step+x1*channels+2] = colr[y1][x1];
     }       
  }   
   return paintImage;      
}

//averaging function
 IplImage* average(IplImage* img)
 {
          
   unsigned int	X, Y;
   int	        I, J;
   int			SUM;
   int          MASK[5][5]; 
    /* 5x5 Average mask.  Ref: Myler Handbook p. 135 */
   MASK[0][0] = 1; MASK[0][1] = 1; MASK[0][2] = 1; MASK[0][3] = 1; MASK[0][4] = 1;
   MASK[1][0] = 1; MASK[1][1] = 1; MASK[1][2] = 1; MASK[1][3] = 1; MASK[1][4] = 1;
   MASK[2][0] = 1; MASK[2][1] = 1; MASK[2][2] = 1; MASK[2][3] = 1; MASK[2][4] = 1;
   MASK[3][0] = 1; MASK[3][1] = 1; MASK[3][2] = 1; MASK[3][3] = 1; MASK[3][4] = 1;
   MASK[4][0] = 1; MASK[4][1] = 1; MASK[4][2] = 1; MASK[4][3] = 1; MASK[4][4] = 1;              
 IplImage* averageImage;
 int height,width,step, channels;
 uchar *data, *data1;
 int i = 0, j = 0, r, g, b;
 height    = img->height;
 width     = img->width;
 step      = img->widthStep;
 channels = img->nChannels;
 data      = (uchar *)img->imageData;
   
  averageImage = cvCreateImage(cvSize(width, height), img->depth, channels);  
  data1     = (uchar *)averageImage->imageData;
          
   struct rgb rgbval[height][width];
   double intensity[height][width];
   int y1, x1;
   for(y1=0;y1<height;y1++) {
      for(x1=0;x1<width;x1++) {
          
          intensity[y1][x1] = (data[y1*step+x1*channels+0] + 
                                  data[y1*step+x1*channels+1] + 
                                     data[y1*step+x1*channels+2])/3;
      }
   }
 
 for(Y=0; Y<=height-1; Y++)  {
	for(X=0; X<=width-1; X++)  {
	     SUM = 0;

	  // image boundaries 
	  if(Y==0 || Y==1 || Y==height-2 || Y==height-1)
		  SUM = 0;
	  else if(X==0 || X==1 || X==width-2 || X==width-1)
		  SUM = 0;

	  // Convolution starts here 
	  else   {
	     for(I=-2; I<=2; I++)  {
		 for(J=-2; J<=2; J++)  {
                   SUM = SUM + (int)(intensity[Y+I][X+J] * MASK[I+2][J+2]);
		 }
	     }
	  }
	     SUM = SUM/25;
	     
	     if(SUM>255)  SUM=255;
	     if(SUM<0)    SUM=0;

         intensity[Y][X] = SUM;
         
          struct rgb rgbtemp;
          struct rgb rgbtemp1;
          rgbtemp.blue = data[Y*step+X*channels+0];
          rgbtemp.green = data[Y*step+X*channels+1];
          rgbtemp.red = data[Y*step+X*channels+2];
          struct hsi hsitemp = rgb2hsi(rgbtemp);
          
          hsitemp.intensity = SUM;
          rgbtemp1 = hsi2rgb(hsitemp);
          data1[Y*step+X*channels+0] = rgbtemp1.blue*0.8 + rgbtemp.blue*0.2;
          data1[Y*step+X*channels+1] = rgbtemp1.green*0.8 + rgbtemp.green*0.2;
          data1[Y*step+X*channels+2] = rgbtemp1.red*0.8 + rgbtemp.red*0.2;  

	}
   }
     return   averageImage;  
}

//Halftoning 
IplImage* halfToning(IplImage* img)
{
 IplImage* grayScaleImage;
 int height,width,step,channels;
 uchar *data, *data1;
 int i = 0, j = 0, r, g, b;
 height    = img->height;
 width     = img->width;
 step      = img->widthStep;
 channels  = img->nChannels;
 data      = (uchar *)img->imageData;
  
  grayScaleImage = cvCreateImage(cvSize(width, height),8,1);
  data1     = (uchar *)grayScaleImage->imageData;
  int temp = 0;
 for(i=0;i<height;i++) 
  {
     for(j=0;j<width;j++) 
     {
           b = data[i*step+j*channels+0];
           r = data[i*step+j*channels+1];
           g = data[i*step+j*channels+2];
           temp = ( r + g + b ) / 3;
           
           if(temp >= 170)
           data1[i*grayScaleImage->widthStep+j+0] = 0;
           else if(temp >= 70 && temp < 170)
           data1[i*grayScaleImage->widthStep+j+0] = 120;
           else
           data1[i*grayScaleImage->widthStep+j+0] = 255;
     }
  }
  
  return grayScaleImage;  
}