imageprocessing.cpp

Go to the documentation of this file.

 #include <stdlib.h>

#include "imageprocessing.h"


        int threshold_red=0;//=250;
    int threshold_green=0;//=250;
        int threshold_blue=0;//=100;


int init_imageprocessing() {

        char *green = getenv( "GREEN" );
        if ( green ) threshold_green= atoi(green);
        char *blue = getenv( "BLUE" );
        if ( blue ) threshold_blue= atoi(blue);
        char *red = getenv( "RED" );
        if ( red ) threshold_red= atoi(red);
    printf("red : %d , green %d, blue %d",threshold_red,threshold_green,threshold_blue);
        //exit(0);
    return 0;
}

Image *get_component (Image *inputImage , int color)
{
    Image *resultImage;
        Matrix *mat;
        Image *temp;

        if (color == RGB_RED)   // RED COMPONENT
        {
                Image *band2, *band3 ;
                band2 = duplicate_Image(inputImage);
                band3 = duplicate_Image(inputImage);
                band2 = extract_band(band2, 2);
                band3 = extract_band(band3, 3);
                inputImage = extract_band(inputImage, 1);
                inputImage = gray_multiply2(inputImage,2.0);    
                inputImage = subtract_Image(inputImage, band2);
                inputImage = subtract_Image(inputImage, band3);
        }


        if (color == RGB_GREEN)   // GREEN COMPONENT
        {
                Image *band1, *band3 ;
                band1 = duplicate_Image(inputImage);
                band3 = duplicate_Image(inputImage);
                band1 = extract_band(band1, 1);
                band3 = extract_band(band3, 3);
                inputImage = extract_band(inputImage, 2);
                inputImage = gray_multiply2(inputImage,2.5);    
                inputImage = subtract_Image(inputImage, band1);
                inputImage = subtract_Image(inputImage, band3);
        }
                

        if (color == RGB_BLUE)   // BLUE COMPONENT
        {
                Image *band1, *band2 ;
                band1 = duplicate_Image(inputImage);
                band2 = duplicate_Image(inputImage);
                band1 = extract_band(band1, 1);
                band2 = extract_band(band2, 2);
                inputImage = extract_band(inputImage, 3);
                inputImage = gray_multiply2(inputImage,2.0);    
                inputImage = subtract_Image(inputImage , band1);
                inputImage = subtract_Image(inputImage , band2);
        }
                        
   //log_Image(inputImage);
// log_Image(inputImage,"_subtractedband");


// DEBUG //     Image *band1 = duplicate_Image(inputImage);
// DEBUG //     band1=remap_Image(band1 ,CVIP_SHORT,0,255);
// DEBUG //     view_Image(band1,"remapaftersubtract.ppm");

// DEBUG //view_Image(inputImage,"aftersubtract.ppm");

    
//  temp = remap_Image(inputImage ,CVIP_SHORT,-255,255);
//temp = remap_Image(inputImage ,CVIP_SHORT,0,255);

        // pak alleen de hoge waardens
//      temp = gray_linear(inputImage ,200.0,510.0,0.0 ,1.0,0, -1);
        
        // doe threshold at 250 (red)
        // doe threshold at 150 (blue)
//      temp = gray_linear(inputImage ,250.0,510.0,100.0 ,0.0,0, -1);
        // 0 -> 310
        if (color == RGB_BLUE) {
                temp = gray_linear(inputImage ,threshold_blue,510.0,100.0 ,0.0,0, -1);
    }
        if (color == RGB_RED) {
                temp = gray_linear(inputImage ,threshold_red,510.0,100.0 ,0.0,0, -1);
    }
        if (color == RGB_GREEN) {
                temp = gray_linear(inputImage ,threshold_green,510.0,100.0 ,0.0,0, -1);
    }



    //view_Image(inputImage,"band1short");
//DEBUG //view_Image(temp,"afterthreshold.ppm");

        // remap data in 0-100 range
        //temp = remap_Image(temp ,CVIP_SHORT,0,255);

//      delete_Image(inputImage);



 // remap to scale for good convolve ( type must be short for convolve!)
        temp = remap_Image(temp ,CVIP_SHORT,0,100);
        
        // blur image to make nice full continuous objects
        mat=(Matrix *)get_default_filter(BLUR_SPATIAL,7,0);
        temp = (Image *)convolve_filter(temp,mat);
        //temp = (Image *)convolve_filter(temp,mat);
        //temp = (Image *)convolve_filter(temp,mat);

// DEBUG // view_Image(temp,"afterblur.ppm");

        delete_Matrix(mat);

        // cut off object edge at 70%  of value after blur
//      temp = gray_linear(temp ,130.0,255.0,255.0,0.0,0, -1);
        temp = gray_linear(temp ,50,255.0,255.0,0.0,0, -1);
        

    resultImage = remap_Image(temp ,CVIP_BYTE,0,255);   
        delete_Image(temp);
   
//    log_Image(resultImage,"_component");
    //log_Image(resultImage);
    return resultImage;
}

Image *find_color_entities(Image *inputimage, int color , 
                          ENTITYLIST *entitylist )
{
     int row,col,angle,label,center_row,center_col,ret;
     long entityarea;
     int *ctr;
     Image *component_img;
     Image *labeled_img;
     Entity entity;


        if (color == RGB_BLUE  && ! threshold_blue) {
                 return inputimage;
    }
        if (color == RGB_RED  && ! threshold_red) {
                 return inputimage;

    }
        if (color == RGB_GREEN  && ! threshold_green) {
                 return inputimage;
    }

 
     // get color entitys in labeled image
     component_img=get_component(inputimage, color);
   
    // label entitys ( connented values not null)
     if ( !get_first_non_null_point(component_img,&row,&col) ) {
                printf("first label : EMPTY IMG ");
        //return false;
                return component_img;
        }
    Image *temp = duplicate_Image(component_img); 
    labeled_img = ::label(temp);


    entity.setColor((Entity::Color)color);

    // per entity
    // 1. find first coordinates row col of a entity with label  'label'
    //    start with first label=1
    label=1;
    row=col=0;
    //get_first_non_null_point(labeled_image, &row,&col);
            // find labeled entity with label higher than 'label'
    while ( find_labeled_entity(labeled_img,row,col,label) ) {
       //myprintf("label,pos: %d %d %d  ", label,row ,col);
        
       // 2. determine area a --> obj_type  
       entityarea=area(labeled_img,row,col);
       printf("area : %d",entityarea);
        
       // 3. find center coordinates 
       if  ( (SUBJECT_MINAREA < entityarea) && (entityarea <= GOAL_MAXAREA ) ) {
           // find center
           ctr=centroid(labeled_img,row,col);
           center_row=ctr[0];
           center_col=ctr[1];

           entity.setX(center_col);
                   //swap orientation y-as!!
           entity.setY(240-center_row);
           delete(ctr);
       }


/*       
       // 4. set entity type, and if type=robot find angle 
       if  ( (ROBOT_MINAREA < entityarea) && (entityarea <= ROBOT_MAXAREA ) ) {
           // set type to robot
           entity.setType(Entity::ROBOT);
           // find angle robot
           ret=robot_angle(component_img,center_row,center_col,angle); 
           if (ret ) {
              entity.setAngle(angle);
              // 5. add entity to entitylist
              entitylist->push_back(entity); 
              //myprintf("rover:\n  angle=%d,row=%d,col=%d,",angle,row,col);
           }
       }
*/
       if  ( (SUBJECT_MINAREA < entityarea) && (entityarea <= SUBJECT_MAXAREA ) ) {
           // set type 
           entity.setType(Entity::SUBJECT);
           // 5. add entity to entitylist
           entitylist->push_back(entity); 
           //myprintf("subject:\n  row=%d,col=%d,",row,col);
       }
/*
       if  ( (GOAL_MINAREA < entityarea) && (entityarea <= GOAL_MAXAREA ) ) {
           // set type 
           entity.setType(Entity::GOAL);
           // 5. add entity to entitylist
           entitylist->push_back(entity); 
           //myprintf("goal:\n  row=%d,col=%d,",row,col);
       }
     */ 
       label++;
    }




 

        delete_Image(labeled_img);

    return component_img;

}







// returns true if non-null pixel found
// row,column : coordinates of this pixel
// inputImage : not changed (not deleted from memory)
bool get_first_non_null_point(Image *inputImage, int *row,int *column)
{
    int r, c, rows ,cols;
    bool found=false;
    byte **image;


    rows = getNoOfRows_Image(inputImage);
    cols = getNoOfCols_Image(inputImage);
        image = (unsigned char ** )getData_Image(inputImage, 0);
    for(r=0; r < rows; r++) 
        {
        for(c=0; c < cols; c++) 
                {
                if (!found)
                        {
                                if ( image[r][c] != 0 ) 
                                {
                                        *row=r;
                        *column=c;
                                        found = true;
                                }
                        }
        }
    }
        
        return found;
}

bool find_labeled_entity(Image *inputImage, int &row,int &col, int &label) {
    int r, c, rows ,cols;

    //byte **image;
    int **image;

    // get dimensions of image
    rows = getNoOfRows_Image(inputImage);
    cols = getNoOfCols_Image(inputImage);
    // access data in image
//      image = (unsigned char ** )getData_Image(inputImage, 0);
    image = (int ** )getData_Image(inputImage, 0);
    // search for object with label value 'label'
    // starting at 'row','col' until end of image
    for(r=row; r < rows; r++) 
        {
        for(c=0; c < cols; c++) 
                {
            // check for new label value which 
            //   - must not be equal old label
            //   - and label must not be 0 (means no object)
            if ( image[r][c] == label ) 
                        {
                    label=image[r][c];
                    row=r;
                    col=c;                    
                    return true;
                        }
        }
    }
    return false;
}

  

---