ImageProcessor.cpp

Go to the documentation of this file.

// ImageProcessor.cpp: implementation of the ImageProcessor class.
//

#include "stdafx.h"
//#include "legoproject.h"

#include "resource.h"
#include "legoprojectDlg.h"

//#include "CVIPtoolsInc.h"
#include "ImageProcessor.h"

#include "defines.h"


#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif


//#include "rover_pc.h" // this may NOT be include in a MFC class (only generic classes)
                       // otherwise message map wil give compile errors




























#define WINAPI __stdcall

int myview =0;

//const WM_TAKEPICT= WM_USER + 100;

// Construction/Destruction





//extern CLegoprojectDlg *dlg;



int iImageCount=0;
char szNameFormat[100];
char szFileName[100];

ImageProcessor::ImageProcessor()
{
 

}

ImageProcessor::~ImageProcessor()
{

}



Image *ImageProcessor::dib2cvip(CImage  *dib)
{
        int rows=(int)dib->m_pbi->biHeight;
        int cols=(int)dib->m_pbi->biWidth;
        byte *pixels=(BYTE *)dib->m_lpbits;

    Image *cvipImage = NULL;
    //LPVOID result;
        int r, c, b;
        byte **image;
        byte *p;
 
        cvipImage = new_Image(PPM,RGB,3,rows,cols,CVIP_BYTE,REAL);

        for(b=0; b< 3; b++) 
        {
                image = (byte **)getData_Image(cvipImage,b);
                p=(byte *)pixels;
                for(r=rows-1;r>=0;r--)
                        for(c=0;c<cols;c++) 
                        {//scanline alligment!!
                        // p[0] is Blue , p[1] is Green, p[2] is Red
                                image[r][c]=(byte)p[2-b]; //BGR in BMP
                                p +=3;
                        }
        }
//      result = (void *)cvipImage;
  //  return result;
    return cvipImage;
}

void ImageProcessor::cvip2dib(CImage  *dib, Image *cvipImage)
{
  int rows=(int)dib->m_pbi->biHeight;
  int cols=(int)dib->m_pbi->biWidth;
  byte *pixels=(BYTE *)dib->m_lpbits;

 // Image *cvipImage = NULL;
 // Image *cvipImage_unmapped = NULL;
 // cvipImage_unmapped= (Image*) cvipImageVoid;
  
 // byte conversie naar standaard byte formaat used by CImage 
 cvipImage=remap_Image(cvipImage,CVIP_BYTE, 0, 255);
 //delete_Image(cvipImage_unmapped); 
 
 int r, c, b;
 byte **imagetwee;
 byte *p;

 
 for(b=0; b< getNoOfBands_Image(cvipImage); b++) {
   imagetwee = (byte **)getData_Image(cvipImage,b);
   p=(byte *)pixels;
   for(r=rows-1;r>=0;r--)for(c=0;c<cols;c++) {//scanline alligment!!
   //  p[2-b]=200;
              p[2-b]= imagetwee[r][c];
     p += 3;
   }
 }
 
 delete_Image(cvipImage);
}


// CVIP image
//  3 separate matrices (RGB order), one for each color

// DIB/VIS image
//   1 matrix with pixel structures, a pixel is in BGRA order 
//   (A reserved for future)

// => walk through DIB/VIS matrix filling the three separate CVIP color matrices

void ImageProcessor::vis2cvip(Image *cvipImage, CImage  *vis)
{
    // incoming CVIP Image
    //Image *cvipImage = (Image *) cvipImageVoid;

    // incoming VIS Image
        int rows=vis->visimage.Height();
        int cols=vis->visimage.Width();
        byte *pixels=(BYTE *)vis->visimage.RowPointer(0);


    // work variables
        int r, c, b;

        byte *p;
    
     byte **image[3];
    // let image reference the three color bands (RGB) of the CVIP image
        for(b=0; b< 3; b++) 
        {
                image[b] = (byte **)getData_Image(cvipImage,b);
    }

                p=(byte *)pixels;
        // loop in reverse way through rows 
        //    DIB has bottom row first in memory  (DOWN-TOP)
        //    CVIP has it the other way around    (TOP-DOWN) 
        //    VIS has the same as CVIP            (TOP-DOWN)
                //for(r=rows-1;r>=0;r--)
        for(r=0;r<rows;r++)
        {   
            // loop through columns
                        for(c=0;c<cols;c++) 
            { 
                // loop through color bands RGB
                    for(b=0; b< 3; b++) 
                {
                   
                               // p[0] is Blue , p[1] is Green, p[2] is Red
                                   image[b][r][c]=(byte)p[2-b]; //BGR in BMP
                                   //p +=3;
                   //p++;
                   //if (b > 0 ) { image[b][r][c]=0; }
                }
                p+=4;
            }
         }
  
}


void ImageProcessor::cvip2vis(CImage  *vis, Image *cvipImage)
{
    // incoming CVIP Image
  //  Image *cvipImage = (Image *) cvipImageVoid;
        int rows=getNoOfRows_Image(cvipImage);
        int cols=getNoOfCols_Image(cvipImage);
    int bands=getNoOfBands_Image(cvipImage);
    // incoming VIS Image
    if (! vis->visimage.IsValid()) {
        vis->visimage.Allocate(cols,rows);
    }
        //int rows=vis->visimage.Height();
        //int cols=vis->visimage.Width();
        byte *pixels=(BYTE *)vis->visimage.RowPointer(0);
    // byte *pixels=vis->visimage.PbPixel(vis->visimage.StartPoint(), 0);
   // byte *pixels=(BYTE *)(vis->visimage.MemBlock()->PbData);

  

    // work variables
        int r, c, b;

        byte *p;
    

    byte **image[3];
    // let image reference the three color bands (RGB) of the CVIP image
        for(b=0; b< bands; b++) 
        {
                image[b] = (byte **)getData_Image(cvipImage,b);
    }

                p=(byte *)pixels;
        // loop in reverse way through rows 
        //    DIB has bottom row first in memory  (DOWN-TOP)
        //    CVIP has it the other way around    (TOP-DOWN) 
        //    VIS has the same as CVIP            (TOP-DOWN)
                //for(r=rows-1;r>=0;r--)
        for(r=0;r<rows;r++)
        {   
            // loop through columns
                        for(c=0;c<cols;c++) 
            { 
                // loop through color bands RGB
                    for(b=0; b< bands; b++) 
                {
                   
                               // p[0] is Blue , p[1] is Green, p[2] is Red
                                   //image[b][r][c]=(byte)p[2-b]; //BGR in BMP
                   p[2-b]=(unsigned char) image[b][r][c]; //BGR in BMP
                                   //p +=3;
                   //p++;
                   //if (b > 0 ) { image[b][r][c]=0; }
                }
                p+=4;
            }
         }
  
       
}



// IMAGE PROCESSING ALGORITHM
//
// this algorithm is executed in thread or by single un
//
//
// howto use alternative viewer   
// view_Image(cvipImage,"view_image");
//
// howto write/read input image to/from file
// IMAGE_FORMAT format=PPM;
// char sFile[]="c:\\TEMP\\temp.ppm";
// inputImage=read_Image(sFile,CVIP_NO); 
//
// how to free an image
// delete_Image(inputImage);
Image  *ImageProcessor::MyAlgorithm(Image *cvipImage)
{     
    // to let the log_Image function work
    // if this is not wanted (for speed) comment out the next line

#define  LOGIMAGE 

         
    // VIEWER is defined in CVIP.h 
    (void) setDisplay_Image(VIEWER, "Default");
    
    iImageCount=0;

    char *logpath= get_log_path();
    delete_old_logimages(logpath);  
        delete logpath;


     // pgm -> gray, or ppm -> color file
    
    List <Entity> objectlist;
    Image *tmp1,*tmp2,*blue_comp,*red_comp,*green_comp;
    tmp1 = duplicate_Image(cvipImage);
//    tmp2 = duplicate_Image(cvipImage);
    blue_comp=find_color_objects(cvipImage,LEGO_BLUE,&objectlist);
    //delete_Image(blue_comp);
    red_comp=find_color_objects(tmp1,LEGO_RED,&objectlist);
    //delete_Image(red_comp);

        blue_comp=add_Image(blue_comp,red_comp);
        log_Image(blue_comp,"_all_objects");

 //   green_comp=find_color_objects(tmp2,LEGO_GREEN,&objectlist);
 //   delete_Image(green_comp);
    
    print_entities(&objectlist);
        send_entities(&objectlist);
   
    //Sleep(500)
    return blue_comp;
}


void print_entities(List <Entity> *objectlist) 
{
    List <Entity>::iterator i;
    int color,type,x,y,angle;
    myprintf("--------");
    for ( i= objectlist->begin(); i != objectlist->end(); ++i )
    { 
        color=(*i).getColor();
        x=(*i).getX();
        y=(*i).getY();
        type=(*i).getType();
        if ( type == Entity::ROBOT ) {
            angle=(*i).getAngle();
            myprintf("robot \r\n %d,%d,%d,%d",x,y,angle,color);
        } 
        if ( type == Entity::SUBJECT ) {
            myprintf("subject \r\n %d,%d,%d",x,y,color);
        }
        if ( type == Entity::GOAL ) {
            myprintf("goal \r\n %d,%d,%d",x,y,color);
        }        
    }

}

void send_entities(List <Entity> *objectlist) 
{
    List <Entity>::iterator i;
    short color,type,x,y,angle;
    myprintf("--------");
    for ( i= objectlist->begin(); i != objectlist->end(); ++i )
    { 
        color=(*i).getColor();
        x=(*i).getX();
        y=(*i).getY();
        type=(*i).getType();

        packetx *cmd_pack; 
                cmd_pack=new packetx(sizeof(color)+sizeof(type)+sizeof(x)+sizeof(y)+sizeof(angle));
                cmd_pack->set_pack_mode();
                cmd_pack->process(color);
                cmd_pack->process(type);
                cmd_pack->process(x);
                cmd_pack->process(y);


        if ( type == Entity::ROBOT ) {
            angle=(*i).getAngle();
                        cmd_pack->process(angle);
            cmd_pack->send(ADDR_RCX,PORT_PC);
        } 

        if ( (type == Entity::SUBJECT ) || (type == Entity::GOAL) ) {
            cmd_pack->send(ADDR_RCX,PORT_PC);
        }
                
                delete(cmd_pack);
    }

}


// per color
Image *find_color_objects(Image *inputimage, int color ,
                               List <Entity> *objectlist ) 
{
     int row,col,angle,label,center_row,center_col,ret;
     long objectarea;
     int *ctr;
     Image *component_img;
     Image *labeled_img;
     Entity object;

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


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

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

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

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

       label++;
    }



 
 

        delete_Image(labeled_img);

    return component_img;

}


bool ImageProcessor::Init(LPVOID param)
{
        CLegoprojectDlg *mdlg;
        mdlg = (CLegoprojectDlg*)param;
        DWORD dwThreadID;
        
        h_MyThread = CreateThread(NULL,0,mdlg->imageproc.MyThread,mdlg,NULL,&dwThreadID);
        if (!h_MyThread) {
                AfxMessageBox("Thread not started (?!?)", MB_ICONINFORMATION | MB_OK);
                return 0;
        }
        //SetThreadPriority(h_MyThread,THREAD_PRIORITY_BELOW_NORMAL);
        return 1;
}



bool ImageProcessor::Stop()
{
        Sleep(700);
   // StopThread(h_MyThread);
    return 1;
}


 DWORD __stdcall ImageProcessor::MyThread(LPVOID pParam)
//AFX_THREADPROC   ImageProcessor::MyThread(LPVOID pParam)
{
        CLegoprojectDlg *mdlg;   // Main Dialog window
        mdlg = (CLegoprojectDlg*) pParam;

        ImageProcessor *MyImageProc;     // instantie van ImageProcessor object
        MyImageProc = (ImageProcessor*)&(mdlg->imageproc);

        // images used
        CImage *vis = NULL; // format to view in dialog
    CImage *visout = NULL; // format to view in dialog
        //Image *cvipimage = NULL; //format used in CVIPtools
        Image *cvipimage = NULL;
    Image *viewimage = NULL;


        // laat dib naar workimage wijzen
    vis=&(mdlg->m_image2);
    visout=&(mdlg->m_image3);

    // send  "take picture" message to dialog class
    PostMessage(mdlg->dlghandle,WM_TAKEPICT,0,0);

    // wait for "picture taken" event signaled
    WaitForSingleObject(mdlg->picttaken,INFINITE);

    int rows=vis->visimage.Height();
        int cols=vis->visimage.Width(); 

    while (mdlg->imageprocessor_active) {       
          
      // get_image

      // send  "take picture" message to dialog class
          PostMessage(mdlg->dlghandle,WM_TAKEPICT,0,0);

          // wait for "picture taken" event signaled
      WaitForSingleObject(mdlg->picttaken,INFINITE);

      // get new empty 3 band image (changed in loop to 1 band);
      cvipimage = new_Image(PPM,RGB,3,rows,cols,CVIP_BYTE,REAL);



    // convert image to format used by CVIPtools
          MyImageProc->vis2cvip( cvipimage,vis);
      
          // imageprocessing
      cvipimage=MyImageProc->MyAlgorithm(cvipimage);
      // WATCH OUT : image returned only one band

      // transform image to visible 0-255 byte format
      viewimage = remap_Image(cvipimage ,CVIP_BYTE,0,255);
      delete_Image(cvipimage);

          // convert image back to format used for viewing in dailog window
          MyImageProc->cvip2vis(visout,viewimage);
          delete_Image(viewimage);

      //  alternatives :  show a logged image
      //view_logged_Image(visout,2); // reads logged image into visout (which is shown in m_image3)
      //mdlg->OpenLogNumber(2); // reads logged image directly from file into m_image3
    
      visout->Invalidate(TRUE); 
    }
        DWORD ExitCode=0;
        ExitThread(ExitCode);
        return 0;
}

void ImageProcessor::SingleRun(LPVOID pParam)
{
        CLegoprojectDlg *mdlg;   // Main Dialog window
        mdlg = (CLegoprojectDlg*) pParam;

        ImageProcessor *MyImageProc;     // instantie van ImageProcessor object
        MyImageProc = (ImageProcessor*)&(mdlg->imageproc);

        // images used
        CImage *vis = NULL; // format to view in dialog
    CImage *visout = NULL; // format to view in dialog
        //Image *cvipimage = NULL; //format used in CVIPtools
        Image *cvipimage = NULL;
    Image *viewimage = NULL;

        // laat dib naar workimage wijzen
    vis=&(mdlg->m_image2);
  
    visout=&(mdlg->m_image3);


    // get_image
        vis->Snap();
        /* following doesn't work
    // send  "take picture" message to dialog class
    PostMessage(mdlg->dlghandle,WM_TAKEPICT,0,0);
    // wait for "picture taken" event signaled
    WaitForSingleObject(mdlg->picttaken,INFINITE);
    */


    int rows=vis->visimage.Height();
        int cols=vis->visimage.Width(); 

    // get new empty 3 band image (changed in loop to 1 band);
    cvipimage = new_Image(PPM,RGB,3,rows,cols,CVIP_BYTE,REAL);

    // convert image to format used by CVIPtools
        MyImageProc->vis2cvip(cvipimage,vis);
      
        // imageprocessing
    cvipimage=MyImageProc->MyAlgorithm(cvipimage);
    
    // transform image to visible 0-255 byte format
    viewimage = remap_Image(cvipimage ,CVIP_BYTE,0,255);
    delete_Image(cvipimage);
        
    // convert image back to format used for viewing in dailog window
        MyImageProc->cvip2vis(visout,viewimage);
        delete_Image(viewimage);

    //  alternatives :  show a logged image
    //view_logged_Image(visout,2); // reads logged image into visout (which is shown in m_image3)
    //mdlg->OpenLogNumber(2); // reads logged image directly from file into m_image3
   
    visout->Invalidate(TRUE);   
}



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

        if (color == LEGO_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 == LEGO_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 == LEGO_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");

    Image *temp;
        temp = remap_Image(inputImage ,CVIP_SHORT,-255,255);
        delete_Image(inputImage);

    //view_Image(inputImage,"band1short");

        mat=(Matrix *)get_default_filter(BLUR_SPATIAL,5,0);
        temp = (Image *)convolve_filter(temp,mat);
    delete_Matrix(mat);
        temp = gray_linear(temp ,130.0,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;
}

// returns true if a non-null pixel exist 
// center_row and center_col are set to the  center of 
// the non-null area attached to this pixel
// inputImage : not changed (not deleted from memory)
bool get_centroid_off_first_object(Image *inputImage, int *center_row, int *center_col)
{
    int row,col;
    Image *lab = NULL;
        lab             = duplicate_Image(inputImage);
  
    // get the coordinates of the first pixel with non-null value
        // if no non null pixel are found then return
    //   -> otherwise label function makes no sense!!
    //         (even crashes?)
    if ( !get_first_non_null_point(lab,&row,&col) ) {
                myprintf("first label : EMPTY IMG ");
        return false;
        }
    // label objects ( connented values not null)
        lab             = label(lab); //-> if more than one object found -> error
    // find centroid of object containing first non-null point
        int *ctr=centroid(lab,row,col);
    delete_Image(lab);
    *center_row=ctr[0];
    *center_col=ctr[1]; 
    delete(ctr);

    return true;
}




// 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_object(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++) 
                {
                
          //  if ( image[r][c] != 0) {
          //     myprintf("r,c,i[r,c] : %d %d %d", r,c, image[r][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) && (image[r][c] !=0)  ) 
            if ( image[r][c] == label ) 
                        {
                    label=image[r][c];
                    row=r;
                    col=c;                    
                    return true;
                        }
        }
    }
    return false;
}


bool robot_angle(Image *inputimage,int &center_row,int &center_col,int &angle) 
{

    //--------------------------------------------------
    // segmenting the little  circle(s)
    //--------------------------------------------------
    //Image *bigcircle_with_holes=remap_Image(inputimage,CVIP_BYTE,0,255);
    Image *Ccircle,*big_circle,*holes, *holes_and_edgecircle;

        // creating a circle a little smaller than the bigcircle
        Ccircle                 = create_circle(320,240,center_col,center_row,6);  

 

    Image *bigcircle_with_holes,*bigcircle_with_holes_copy1,
           *bigcircle_with_holes_copy2;

    bigcircle_with_holes        = duplicate_Image(inputimage); 
    bigcircle_with_holes_copy1  = duplicate_Image(inputimage);
    bigcircle_with_holes_copy2  = duplicate_Image(inputimage);
    //log_Image(bigcircle_with_holes);

    holes_and_edgecircle        = xor_Image(bigcircle_with_holes_copy2,Ccircle); 
    big_circle              = or_Image(bigcircle_with_holes_copy1,holes_and_edgecircle);
    holes                           = xor_Image(bigcircle_with_holes,big_circle);
    log_Image(holes,"_holes");
//      log_Image(holes);
    // holes :
    // - if we only have the white hole -> we found this white hole
          //white_hole=holes;
    // - however when there is also a black hole, than we have found
    //   both the black and white hole
           // we than should label both objects. For each found object
           // sum the pixel values of the colorband -> the one with 
          //    - the lowest value : black circle
          //    - highest value : white circle
   // --> advantages : 
     //   - the angle is more precise !!            
     //   - the center is the real center !!
   
    //if (myview ) view_Image(temp,"view_image");

    

    // find center of hole
    int center_row_hole,center_col_hole;
    bool found=get_centroid_off_first_object(holes,&center_row_hole,&center_col_hole);
    if ( !found )
    {
                myprintf("first label : EMPTY IMG ");
        delete_Image(holes);
        return( false ) ;
        }    
    delete_Image(holes);     
    
    

    int delta_col,delta_row;
        delta_col = center_col_hole - center_col; 
        delta_row = center_row_hole - center_row;

 
    // calculate angle
    //   put - sign before delta_row because in a normal mathematical sense
    //   the y-axis has the opposite direction as the row axis
    angle=atan2(-delta_row ,delta_col )*180/PI;

        if (angle < -180) angle = angle +180;
        if (angle >  180) angle = angle -180;


    


    return true;
}





  
void log_Image(Image *cvipimage, char *description)
{

#ifdef LOGIMAGE




    iImageCount++;



        // set logpath
        char *logpath= get_log_path();
    strcpy(szNameFormat,logpath);
        delete logpath;

    if (getNoOfBands_Image(cvipimage) == 3) {
        strcat(szNameFormat,"lego%03d");
                strcat(szNameFormat, description);
                strcat(szNameFormat,".ppm");
 //     strcat(szNameFormat,"C:\\LEGO\\log\\lego%03d.ppm");

        sprintf(szFileName,szNameFormat , iImageCount);
    } else {
        strcat(szNameFormat,"lego%03d");
                strcat(szNameFormat, description);
                strcat(szNameFormat,".pgm");
//      strcat(szNameFormat,"C:\\LEGO\\log\\lego%03d.pgm");

        sprintf(szFileName,szNameFormat , iImageCount);
    }

    Image *resultimage = remap_Image(cvipimage ,CVIP_BYTE,0,255);

    write_Image(resultimage,szFileName,CVIP_YES,CVIP_NO,PPM,CVIP_NO);
#endif
     
}


void view_logged_Image(CImage *visimg, int number)
{

#ifdef LOGIMAGE



        // set logpath
        char *logpath= get_log_path();
    strcpy(szNameFormat,logpath);



//   strcat(szNameFormat,"C:\\LEGO\\log\\lego%03d");
        strcat(szNameFormat,"lego%03d*.p?m");
    sprintf(szFileName,szNameFormat , number);


        // zoekpath met wildcards
        WIN32_FIND_DATA win32finddata;
        HANDLE hFindFirstFile;
        //zoek first file met zoekpath met wildcards
        
        hFindFirstFile = FindFirstFile(szFileName, &win32finddata);

        // indien geen file gevonden , stop met deze loop
    if ( hFindFirstFile == INVALID_HANDLE_VALUE) {
                return;
        }

        // maak found file string
        strcpy(szNameFormat,logpath);
    strcat(szNameFormat,win32finddata.cFileName);
        //debug_printf(szLogFileName);

        delete logpath; 

    visimg->ReadFromFile(szNameFormat);
    //visimg->ReadFromFileGuessExt(szFileName);
#endif
     
}







// determines the angle and position of a Red circle containing a small white circle
//  position -> the center of the red circle
//  angle    -> the disposition of the small white circle in the Red circle 
// returns an image with the white circle
Image *Robot_Position_and_Angle(Image *inputImage)
{
    int row,col,angle;
    Image *result;
    Image *inputImage2=duplicate_Image(inputImage);
    Image *inputImage3=duplicate_Image(inputImage);
    result=Object_Position_and_Angle(inputImage,LEGO_RED,&row,&col,&angle);
    delete_Image(result);
    myprintf("RED pos: r=%d, c=%d, ang: a=%d", row, col, angle);
    result=Object_Position_and_Angle(inputImage2,LEGO_GREEN,&row,&col,&angle);
    delete_Image(result);
    myprintf("GREEN pos: r=%d, c=%d, ang: a=%d", row, col, angle);
    result=Object_Position_and_Angle(inputImage3,LEGO_BLUE,&row,&col,&angle);
    myprintf("BLUE pos: r=%d, c=%d, ang: a=%d", row, col, angle);
    return result;
}

// determines the angle and position of a Basic color (RGB) circle 
// containing a small white circle
//  position -> the center of the red circle
//  angle    -> the disposition of the small white circle in the bigger circle 
// returns an image with the small white circle
/*   example :
     //RED
     result=Object_Position_and_Angle(inputImage3,RED,&row,&col,&angle);
     myprintf("REDs: r=%d, c=%d, ang: a=%d", row, col, angle);
     log_Image(result);
*/
Image *Object_Position_and_Angle(Image *inputImage,int obj_color, int *obj_row, 
                                int *obj_col,int *obj_angle)
{       
    Image *lab = NULL, *Ccircle = NULL;
    Image *bigcircle_with_holes, *holes_and_edgecircle,*big_circle,*holes;


    bool found;
     
    int center_row_1,center_col_1, center_row_2,center_col_2;
        int delta_row, delta_col;

  








  //if (myview ) view_Image(redband,"redband");


    // get the (pure Red or Green or Blue) color component of the image
    // gets the pure color pixels : retrieves a binary (0 or 255) image
    bigcircle_with_holes = get_component(inputImage,obj_color);
        
    // get center of first red object
    found=get_centroid_off_first_object(bigcircle_with_holes,&center_row_1,&center_col_1);
    if ( !found )
    {
                myprintf("first label : EMPTY IMG ");
        return( bigcircle_with_holes) ;
        }    






    //--------------------------------------------------
    // segmenting the little  circle(s)
    //--------------------------------------------------

        // creating a circle a little smaller than the bigcircle
        Ccircle                 = create_circle(320,240,center_col_1,center_row_1,6);  
        
    Image *bigcircle_with_holes_copy1,*bigcircle_with_holes_copy2;
    bigcircle_with_holes_copy1  = duplicate_Image(bigcircle_with_holes); 
    bigcircle_with_holes_copy2  = duplicate_Image(bigcircle_with_holes); 
    //log_Image(bigcircle_with_holes);

    holes_and_edgecircle        = xor_Image(bigcircle_with_holes_copy2,Ccircle); 
    big_circle              = or_Image(bigcircle_with_holes_copy1,holes_and_edgecircle);
    holes                           = xor_Image(bigcircle_with_holes,big_circle);
    log_Image(holes,"_holes");
//  log_Image(holes);

    // holes :
    // - if we only have the white hole -> we found this white hole
          //white_hole=holes;
    // - however when there is also a black hole, than we have found
    //   both the black and white hole
           // we than should label both objects. For each found object
           // sum the pixel values of the colorband -> the one with 
          //    - the lowest value : black circle
          //    - highest value : white circle
   // --> advantages : 
     //   - the angle is more precise !!            
     //   - the center is the real center !!
   
    //if (myview ) view_Image(temp,"view_image");

    

    // find center of hole
    found=get_centroid_off_first_object(holes,&center_row_2,&center_col_2);
    if ( !found )
    {
                myprintf("first label : EMPTY IMG ");
        return( holes) ;
        }    
     
    
    

        delta_col = center_col_2 - center_col_1; 
        delta_row = center_row_2 - center_row_1;

        int angle; 
    // calculate angle
    //   put - sign before delta_row because in a normal mathematical sense
    //   the y-axis has the opposite direction as the row axis
    angle=atan2(-delta_row ,delta_col )*180/PI;

        if (angle < -180) angle = angle +180;
        if (angle >  180) angle = angle -180;

        //  RESULTS
//    myprintf("arrow = ( %d , %d )",delta_col,delta_row);
//      myprintf("pos: r=%d, c=%d, ang: a=%d", center_row_1, center_col_1, angle);

        *obj_angle=angle;
    *obj_row=center_row_1;
    *obj_col=center_col_1;
    return holes;
}

---