Code
Hier worden stukken code gezet, voorafgaand door een combinatie van letters en nummers (bv au12). Naar dit nummer kan dan verwezen worden vanuit de wiki.
De eerste 2 of 3 letters zijn kenmerkend voor de maand waarin de code is geschreven, de 2 cijfers zijn de datum. Zo betekend au12 -> code geschreven op 12 augustus. Elk stuk code dient voorafgaand beschreven te worden door een paar regels uitleg. Ook dient vermeld te worden in welke file de code staat.


JUL28

Code van de controls wat aangepast, zodat je kan sturen via de pijltjes van het toetsenbord.
Pijl omhoog: vooruit
Pijl omlaag: achteruit
Pijl links: links
Pijl rechts: rechts

Spatie: opstijgen/landen
escape: nodlanding
E: effectje

cijferklavier:
8: omhoog
2: omlaag
4: draai rond as links
6: draai rond as rechts

In gamepad.cpp kan je onderstaande functie vervangen:
C_RESULT update_dx_keyboard(void)
{
    static float roll = 0, pitch = 0, gaz=0, yaw=0;
    static int hovering=0;
 
    const char * linefiller="                                              ";
 
 
 
/* Direct Input keyboard state */
        char keyboardState[256];
        static char previous_keyboardState[256];
 
        static bool function_first_call = true;
 
        // Get the keyboard state
        hr = fDIKeyboard->GetDeviceState( sizeof(keyboardState),
                                        (LPVOID)&keyboardState    );
        if (FAILED(hr))    fDIKeyboard->Acquire();
 
 
 
    if (function_first_call) {
        printf("Sending flat trim - make sure the drone is horizontal at client startup.\n");
        ardrone_at_set_flat_trim();
        function_first_call=false;
        vp_os_memcpy(previous_keyboardState,keyboardState,sizeof(keyboardState));
        return C_OK;
 
    }
 
    ARWin32Demo_AcquireConsole();
    ARWin32Demo_SetConsoleCursor(0,12);
 
    // Process the keyboard data
 
    #define EVENTKB(I)      ( keyboardState[I] != previous_keyboardState[I] )
    #define TESTKB(I)       ( keyboardState[I] & 0x80 )
    #define SETKB(I,J)      if( keyboardState[I] & 0x80 )  J(1); else J(0);
 
    /*VOORUIT / ACHTERUIT */
    pitch = //(TESTKB(DIK_NUMPAD2))? (+1.0f) : (TESTKB(DIK_NUMPAD8))? (-1.0f) :
            //(TESTKB(DIK_K))? (+1.0f)       : (TESTKB(DIK_I))? (-1.0f)            :(0.0f) ;
            (TESTKB(DIK_DOWN))? (+1.0f)       : (TESTKB(DIK_UP))? (-1.0f)            :(0.0f) ;//DH
 
    /* LINKS / RECHTS */
    roll  = //(TESTKB(DIK_NUMPAD4))? (-1.0f) : (TESTKB(DIK_NUMPAD6))? (+1.0f) :
            //(TESTKB(DIK_J))? (-1.0f)       : (TESTKB(DIK_L))? (+1.0f)        : (0.0f) ;
            (TESTKB(DIK_LEFT))? (-1.0f)       : (TESTKB(DIK_RIGHT))? (+1.0f)        : (0.0f) ;//DH
 
    /* DRAAIEN ROND AS */
    yaw   = //(TESTKB(DIK_NUMPAD7))? (-1.0f) : (TESTKB(DIK_NUMPAD9))? (+1.0f) :
            //(TESTKB(DIK_NUMPAD3))? (-1.0f) : (TESTKB(DIK_NUMPAD1))? (+1.0f) :
            //(TESTKB(DIK_U))? (-1.0f)       : (TESTKB(DIK_O))? (+1.0f) :  (0.0f) ;
            (TESTKB(DIK_NUMPAD4))? (-1.0f) : (TESTKB(DIK_NUMPAD6))? (+1.0f) :        //DH
            //(TESTKB(DIK_W))? (-1.0f)       : (TESTKB(DIK_X))? (+1.0f) :  (0.0f) ;    //DH
 
    /* OMHOOG / OMLAAG */
    gaz   = (TESTKB(DIK_NUMPAD2))? (-1.0f) : (TESTKB(DIK_NUMPAD8))? (+1.0f) :        //DH
            //(TESTKB(DIK_A))? (-1.0f)       : (TESTKB(DIK_Q))?      (1.0f) : (0.0f) ;
 
 
    hovering = (TESTKB(DIK_G))? (1):(0) ;
 
    keyboard_in_use = !((pitch+roll+gaz+yaw)==0);
 
    /* *************** DH ***************** */
    if (EVENTKB(DIK_E)) {
        if (TESTKB(DIK_E))
            {
                ARWin32Demo_SetConsoleCursor(0,18);            //Cursor op rij 18 plaatsen //DH
                printf("Hier willen we een kunstje doen.\n",linefiller);
                ardrone_at_set_anim( ARDRONE_ANIM_YAW_SHAKE, 2 ) API_WEAK;
            }
    }
    /* ************************************ */
 
 
     if (EVENTKB(DIK_ESCAPE)) {
        if (TESTKB(DIK_ESCAPE))
            {
                exit_ihm_program=0;
            }
    }
 
    if (EVENTKB(DIK_TAB)) {
        if (TESTKB(DIK_TAB))
            {
                ardrone_tool_set_ui_pad_start(0);
                ardrone_tool_set_ui_pad_select(1);
                ARWin32Demo_SetConsoleCursor(0,18);            //Cursor op rij 18 plaatsen //DH
                printf("Sending emergency.%s\n",linefiller);
            }
        else
            {
                    ardrone_tool_set_ui_pad_select(0);
            }
    }
 
    if (EVENTKB(DIK_SPACE) && TESTKB(DIK_SPACE))
        {
            start^=1;
            ardrone_tool_set_ui_pad_start(start);
            printf("Sending start %i.%s\n",start,linefiller);
        }
 
    if (EVENTKB(DIK_F) &&  TESTKB(DIK_F))
        {
            ardrone_at_set_flat_trim();
            printf("Sending flat trim.%s\n",linefiller);
        }
 
 
    ardrone_at_set_progress_cmd((hovering)?0:1,roll, pitch, gaz, yaw);
    printf("[Pitch %f] [Roll %f] [Yaw %f] [Gaz %f]%\n",pitch,roll,yaw,gaz);
 
    vp_os_memcpy(previous_keyboardState,keyboardState,sizeof(keyboardState));
 
    ARWin32Demo_ReleaseConsole();
 
    return C_OK;
}

AU14

custom_code.c aangepast. Nu loopt er een zelfgemaakte thread parallel met de rest van de code. In deze thread wordt er voorlopig alleen maar iets geprint op het consolescherm.

Het belangrijkste stuk code begint met:
/* ******************************** DH *********************************** */
/* *** Thread waar later ons beeldverwerkings algorithme zal in komen ! ** */
/* *********************************************************************** */

/********************************************************************
 *                    COPYRIGHT PARROT 2010
 ********************************************************************
 *       PARROT - A.R.Drone SDK Windows Client Example
 *-----------------------------------------------------------------*/
/**
 * @file custom_code.c
 * @brief User added code
 *
 * @author sylvain.gaeremynck@parrot.com
 * @date 2009/07/01
 *
 * @author Stephane Piskorski <stephane.piskorski.ext@parrot.fr>
 * @date   Sept, 8. 2010
 *
 *******************************************************************/
 
 
 
#include <custom_code.h>
 
//ARDroneLib
    #include <ardrone_tool/ardrone_time.h>
    #include <ardrone_tool/Navdata/ardrone_navdata_client.h>
    #include <ardrone_tool/Control/ardrone_control.h>
    #include <ardrone_tool/UI/ardrone_input.h>
 
//Common
    #include <config.h>
    #include <ardrone_api.h>
 
//VP_SDK
    #include <ATcodec/ATcodec_api.h>
    #include <VP_Os/vp_os_print.h>
    #include <VP_Api/vp_api_thread_helper.h>
    #include <VP_Os/vp_os_signal.h>
 
//Local project
    #include <UI/gamepad.h>
    #include <Video/video_stage.h>
    #include <UI/directx_rendering.h>
 
 
 
 
 
//Global variables
    int32_t exit_ihm_program = 1;
    vp_os_mutex_t consoleMutex;
 
 
/* Implementing Custom methods for the main function of an ARDrone application */
 
 
 
/*--------------------------------------------------------------------
The delegate object calls this method during initialization of an
ARDrone application
--------------------------------------------------------------------*/
 
C_RESULT ardrone_tool_init_custom(int argc, char **argv)
{
    /* Change the console title */
        vp_os_mutex_init(&consoleMutex);
        system("cls");
        SetConsoleTitle(TEXT("Parrot A.R. Drone SDK Demo for Windows"));
 
 
        //CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)&HmiStart,NULL,0,0);                //DH
        //CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)&HmiStart2,NULL,0,0);
 
 
    /* Registering for a new device of game controller */
        ardrone_tool_input_add( &dx_keyboard );
        ardrone_tool_input_add( &dx_gamepad );
 
    /* Start all threads of your application */
        START_THREAD( directx_renderer_thread , NULL);
        START_THREAD( video_stage, NULL );
 
        START_THREAD( DH_test, NULL );                                                //DH
 
 
 
  return C_OK;
}
 
 
 
/*--------------------------------------------------------------------
The delegate object calls this method when the event loop exit
--------------------------------------------------------------------*/
C_RESULT ardrone_tool_shutdown_custom()
{
  /* Relinquish all threads of your application */
  JOIN_THREAD( video_stage );
 
  /* Unregistering for the current device */
  ardrone_tool_input_remove( &dx_gamepad );
  ardrone_tool_input_remove( &dx_keyboard );
 
  /* Mutex needs to be destroyed but may still be used by navdata thread */
  /* todo : synchronize threads shutdown */
  //vp_os_mutex_destroy(&consoleMutex);
 
  return C_OK;
}
 
/*--------------------------------------------------------------------
The event loop calls this method for the exit condition
--------------------------------------------------------------------*/
bool_t ardrone_tool_exit()
{
  return exit_ihm_program == 0;
}
 
C_RESULT signal_exit()
{
  exit_ihm_program = 0;
 
  return C_OK;
}
 
 
 
 
 
 
/* ******************************** DH *********************************** */
/* *** Thread waar later ons beeldverwerkings algorithme zal in komen ! ** */
/* *********************************************************************** */
DEFINE_THREAD_ROUTINE( DH_test, nomParams )
{
  C_RESULT res;
  res = C_OK;
 
  ardrone_at_set_led_animation ( SNAKE_GREEN_RED, 10, 5 ) API_WEAK; //Led effectje starten
 
  while(1)
  {
        ARWin32Demo_AcquireConsole();                //Console opeisen om in te werken
        ARWin32Demo_SetConsoleCursor(0,14);            //Cursor op rij 14 plaatsen
        printf("Om deze regel af te printen draait er een apparte thread!.\n");
        printf("ipv deze regel te printen kunnen we hier ons \n");
        printf("beeldverwerkingsalgorithme in laten draaien.\n");
        ARWin32Demo_ReleaseConsole();                //Console terug vrijgeven voor de andere threads
  }
 
  THREAD_RETURN( res );
}
/* ********************************************************************** */
/* *********************************************************************** */
 
 
 
 
 
 
int custom_main(int argc,char**argv) { return 0;};
 
 
/* Implementing thread table in which you add routines of your application and those provided by the SDK */
BEGIN_THREAD_TABLE
  THREAD_TABLE_ENTRY( ardrone_control, 20 )
  THREAD_TABLE_ENTRY( navdata_update, 20 )
  THREAD_TABLE_ENTRY( video_stage, 20 )
  THREAD_TABLE_ENTRY( directx_renderer_thread, 20 )
  THREAD_TABLE_ENTRY( DH_test, 20 )                            //DH
END_THREAD_TABLE
 
 
 
/* Function to change the cursor place in the console window */
 
    HANDLE hStdout =  NULL;  /* Handle to the output console */
    CONSOLE_SCREEN_BUFFER_INFO csbiInfo;                /* Information about the output console */
 
 
 
void ARWin32Demo_SetConsoleCursor(int x,int y)
{
    if (hStdout==NULL) hStdout=GetStdHandle(STD_OUTPUT_HANDLE);
 
    if (hStdout != INVALID_HANDLE_VALUE){
            GetConsoleScreenBufferInfo(hStdout, &csbiInfo);
            csbiInfo.dwCursorPosition.X=x;
            csbiInfo.dwCursorPosition.Y=y;
            SetConsoleCursorPosition(hStdout,csbiInfo.dwCursorPosition);
    }
}
 
void ARWin32Demo_AcquireConsole(int x,int y)
{
    vp_os_mutex_lock(&consoleMutex);
}
void ARWin32Demo_ReleaseConsole(int x,int y)
{
    vp_os_mutex_unlock(&consoleMutex);
}
 
 

Okt2

Stukje code bijgeschreven om de onderste camera bij in beeld te brengen. Dit stukje code kan je toevoegen in gamepad.cpp. De functie kan je terugvinden in ardrone_at.c

functie in ardrone_at.c:
void ardrone_at_zap( ZAP_VIDEO_CHANNEL channel )
{
  if (!at_init)
     return;
 
  ATcodec_Queue_Message_valist( ids.AT_MSG_ATCMD_ZAP_EXE,
                                ++nb_sequence,
                                channel );
}

De functie gebruikt om het 2de camerabeeld weer te geven:
if (EVENTKB(DIK_C)) {                        //onderste camera
        if (TESTKB(DIK_C))
        {
            ardrone_at_zap(ZAP_CHANNEL_LARGE_HORI_SMALL_VERT); //ardrone_api.h
        }
    }

OKT7

#include <opencv2\opencv.hpp>
#define DEF 0
 
int main()
{
    // Cam initialiseren
    CvCapture* capture = 0;
    capture = cvCaptureFromCAM(0);
 
    //Vensters die we gebruiken
    cvNamedWindow("video");
    cvNamedWindow("thresh");
    cvNamedWindow("smooth");
 
    // We vinden cam ni
    if(!capture)
    {
        printf("Could not initialize capturing...\n");
        return -1;
    }
 
 
    IplImage* frame = 0;
    CvMemStorage * storage = cvCreateMemStorage(0);
    frame = cvQueryFrame(capture);
 
 
 
    IplImage* hsv_frame = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,3);
    IplImage* thresholded = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
    IplImage* thresholded2 = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
 
    CvScalar hsv_min = cvScalar(104,68,60,0);
    CvScalar hsv_max = cvScalar(200-DEF,160-DEF,152-DEF,0);
    CvScalar hsv_min2 = cvScalar(114,80,78,0);
    CvScalar hsv_max2 = cvScalar(221,169,129,0);
 
    for(;;)
    {
        frame = cvQueryFrame(capture);
        if(frame != NULL) {
            cvCvtColor(frame,hsv_frame,CV_BGR2HSV);
            cvInRangeS(hsv_frame,hsv_min,hsv_max,thresholded);
            cvInRangeS(hsv_frame,hsv_min2,hsv_max2,thresholded2);
            cvOr(thresholded,thresholded2,thresholded);
 
            cvShowImage("thresh", thresholded);
 
            cvSmooth(thresholded,thresholded, CV_GAUSSIAN,9,9);
            cvShowImage("smooth", thresholded);
 
            CvSeq* circles = cvHoughCircles(thresholded,storage,CV_HOUGH_GRADIENT,2,200,100,50,20,200);
 
            for(int i =0;i<circles->total;i++)
            {
                float *p = (float*)cvGetSeqElem(circles,i);
                printf("x = %f y = %f straal = %f\n",p[0],p[1],p[2]);
                cvCircle(frame,cvPoint(cvRound(p[0]),cvRound(p[1])),3,CV_RGB(0,255,0),-1,8,0);
                cvCircle(frame,cvPoint(cvRound(p[0]),cvRound(p[1])),cvRound(p[2]),CV_RGB(255,0,0),3,8,0);
            }
 
            cvShowImage("video", frame);
        }
        else
        {
            int c = cvWaitKey(10);
            if(c!=-1)
            {
 
                break;
            }
        }
        int c = cvWaitKey(10);
            if(c!=-1)
            {
                break;
            }
    }
    cvReleaseCapture(&capture);
    return 0;
 
}

NOV2;

Code om rood balletje te vinden in beeld. Ook worden de coordinaten en de straal van het balletje weergegeven en hoe de drone moet vliegen om de bal in het midden van het beeld te krijgen.Ook de verschillende tussenstappen tussen de algoritmes worden weergegeven.
#include "cv.h"
#include "highgui.h"
 
#include <stdio.h>
 
#define MIDHOOGTE 110
#define MIDBREED 150
#define SPELING 60
 
 
int main()
{
    float pos[3];    //Actueele positie bal
    float vpos[3];    //Vorige positie bal
    char ongeldig = 0;    //variable voor ongeldige cirkels te detecteren
 
    vpos[0] = MIDBREED;        //Midden van scherm
    vpos[1] = MIDHOOGTE;    //Midden van scherm
 
    // Cam initialiseren
    CvCapture* capture = 0;
    capture = cvCaptureFromCAM(-1);
 
    //Vensters die we gebruiken
        cvNamedWindow("video");
    cvNamedWindow("thresh");
    cvNamedWindow("smooth");
    cvNamedWindow("erosion");
    cvNamedWindow("dilation");
    cvNamedWindow("firstsmooth");
 
    // We vinden cam ni
    if(!capture)
    {
        printf("Could not initialize capturing...\n");
        return -1;
    }
 
    IplImage* frame = 0;
    CvMemStorage * storage = cvCreateMemStorage(0);
    frame = cvQueryFrame(capture);
 
    IplImage* hsv_frame = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,3);
    IplImage* thresholded = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
    IplImage* thresholded2 = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
 
    IplImage* firstsmooth = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,3);
 
    CvScalar hsv_min = cvScalar(0, 180, 10, 0);    //HSV kleuren !
        CvScalar hsv_max = cvScalar(15, 255, 255, 0); //kleur tussen 0 en 360 rest 0 en 255
    CvScalar hsv_min2 = cvScalar(160, 90, 10, 0);    //HSV kleuren !
        CvScalar hsv_max2 = cvScalar(180, 255, 255, 0); //kleur tussen 0 en 360 rest 0 en 255
 
    for(;;)
    {
        frame = cvQueryFrame(capture);
        cvSmooth(frame,firstsmooth, CV_GAUSSIAN,5,5);//DH
        cvSmooth(firstsmooth,firstsmooth, CV_GAUSSIAN,5,5);//DH
        cvShowImage("firstsmooth", firstsmooth);//DH
 
        if(frame != NULL) {
 
            cvCvtColor(frame,hsv_frame,CV_BGR2HSV);
            cvInRangeS(hsv_frame,hsv_min,hsv_max,thresholded);
            cvInRangeS(hsv_frame,hsv_min2,hsv_max2,thresholded2);
            cvOr(thresholded,thresholded2,thresholded);
 
            cvShowImage("thresh", thresholded);
 
            cvDilate(thresholded,thresholded,0,1);    //eerst dilate om vakjes op te vullen
            cvErode(thresholded,thresholded,0,3);    //Erosion
            cvShowImage("erosion", thresholded);
            cvDilate(thresholded,thresholded,0,2);    //en terug dilate
            cvShowImage("dilation", thresholded);
 
            cvSmooth(thresholded,thresholded, CV_GAUSSIAN,5,5);
            cvShowImage("smooth", thresholded);
 
 
            CvSeq* circles = cvHoughCircles(thresholded,storage,CV_HOUGH_GRADIENT,2,300,80,40,20,200);
 
            for(int i =0;i<circles->total;i++)
            {
                float *p = (float*)cvGetSeqElem(circles,0);
                pos[0] = p[0]; pos[1] = p[1];
                if(pos[0]<vpos[0]-30 || pos[0]>vpos[0]+30 || pos[1]<vpos[1]-30 || pos[1]>vpos[1]+30)
                {
                    printf("ongeldig\n");
                    ongeldig++;
                    if(ongeldig>10)        //Als we lange de bal niet meer vinden, zal de huidige positie wel de bal zijn
                    {
                        vpos[0] = p[0];
                        vpos[1] = p[1];
                        ongeldig = 0;    //resetten
                    }
                }
                else
                {
                    if(pos[1]>MIDHOOGTE+SPELING)        printf("x = %f y = %f straal = %f OMHOOG \n",p[0],p[1],p[2]);
                    else if(pos[1]<MIDHOOGTE-SPELING)    printf("x = %f y = %f straal = %f OMLAAG \n",p[0],p[1],p[2]);
                    else if(pos[0]<MIDBREED-SPELING)    printf("x = %f y = %f straal = %f LINKS  \n",p[0],p[1],p[2]);
                    else if(pos[0]>MIDBREED+SPELING)    printf("x = %f y = %f straal = %f RECHTS \n",p[0],p[1],p[2]);
                    else printf("x = %f y = %f straal = %f\n",p[0],p[1],p[2]);
 
                    vpos[0] = pos[0]; vpos[1] = pos[1];        //Nieuwe positie in oude steken
                }
                cvCircle(frame,cvPoint(cvRound(p[0]),cvRound(p[1])),cvRound(p[2]),CV_RGB(255,0,0),-1,8,0);
                cvCircle(frame,cvPoint(cvRound(p[0]),cvRound(p[1])),3,CV_RGB(0,255,0),-1,8,0);
            }
 
            cvShowImage("video", frame);
        }
        else
        {
            int c = cvWaitKey(10);
            if(c!=-1)
            {
 
                break;
            }
        }
        int c = cvWaitKey(10);
            if(c!=-1)
            {
                break;
            }
    }
    cvReleaseCapture(&capture);
    cvDestroyWindow("video");
    cvDestroyWindow("thresh");
    cvDestroyWindow("smooth");
    cvDestroyWindow("erosion");
    cvDestroyWindow("dilation");
    cvDestroyWindow("firstsmooth");
    return 0;
 
}

NOV2 sec

Stuk code waarvan Maarten een URBI object kan maken om al eens te testen. Deze code pakt beeld binnen van de drone (datanaamvanbeeldinurbi?? moet dan wel nog veranderd worden in de naam van de struct waar urbi mee werkt om het beeld van de drone in op te slaan alsook op de 8ste regel moet verwezen worden naar de data in de struct). De returnwaarde is een int waar de x,y en straal zijn in verwerkt. De laagste 8 bits zijn de x, de volgende 8 bits de y en de volgende 8 bits de straal van de bal. Voorlopig zijn dit vaste waardes.

 int test( datanaamvanbeeldinurbi?? *in)
 {
  int key;
  int i,j;
  int x,y,straal,result;
  CvScalar pix,pix2;
  CvSize size;
 
  pixbuf_data      = (uint8_t*)in->buffers[0];   //in->buffer is een struct , maar je moet eens zien hoe je u beeld binnen pakt met URBI of dat ook in een struct wordt gezet
 
  size = cvSize(640, 480);
  frame = cvCreateImage(size,IPL_DEPTH_8U,3);
  frame2 = cvCreateImage(size,IPL_DEPTH_8U,3);
  frame->imageData = pixbuf_data;
 
  cvCopy(frame,frame2,NULL);                             //BGR to RGBs
      for(i=0;i<480/2;i++){
          for(j=0;j<640/2;j++){
              pix = cvGet2D(frame,i,j);
              pix2.val[0]=pix.val[2];
              pix2.val[1]=pix.val[1];
              pix2.val[2]=pix.val[0];
              cvSet2D(frame2,i,j,pix2);
          }
      }
 
 
  cvShowImage("Camera",frame2);
  key = cvWaitKey(1);
 
  result = 0; x = 50;y = 60; straal = 70
  result = straal;
  result = result << 8;
  result = result || y;
  result = result << 8;
  reslut = result || x;
 
 
  return (result);
  }
 
  //initialisatiefunctie om venster aan te maken moet volgende regel code dan staan:
 
  cvNamedWindow("Camera",CV_WINDOW_AUTOSIZE);//DH //venster maken voor video ff in weer te geven
 
  //Globale variable
  static uint8_t*  pixbuf_data       = NULL;
  IplImage* frame;
  IplImage* frame2;
 
  //en includes
#include <cv.h>
#include <highgui.h>
 


NOV6

Code die in video_stage.c moet staan om bal te detecteren met camera van drone.

De globale variable die ik gebruik:
/* Globale variable voor beeldverwerking */
 
  IplImage* frame;
  IplImage* frame2;
  IplImage* hsv_frame;
  IplImage* thresholded;
  IplImage* thresholded2;
  IplImage* firstsmooth;
  CvSize size;
  CvScalar hsv_min;
  CvScalar hsv_max;
  CvScalar hsv_min2;
  CvScalar hsv_max2;
  //Globale variable voor maarten
  int x;
  int y;
  int visible;
  int radius;

De initialisatie:
C_RESULT output_rendering_device_stage_open( void *cfg, vp_api_io_data_t *in, vp_api_io_data_t *out)
{
    vp_os_mutex_init(&video_update_lock);
    // INITIALISATIE VOOR BEELDVERWERKING
    cvNamedWindow("Camera",CV_WINDOW_AUTOSIZE);//DH //venster maken voor video ff in weer te geven
    cvNamedWindow("thresh",CV_WINDOW_AUTOSIZE);//voor te kijken of kleur klopt
 
    size = cvSize(DRONE_VIDEO_MAX_WIDTH, DRONE_VIDEO_MAX_HEIGHT);
 
    frame = cvCreateImage(size,IPL_DEPTH_8U,3);//DH
    frame2 = cvCreateImage(size,IPL_DEPTH_8U,3);
    hsv_frame = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,3);
    thresholded = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
    thresholded2 = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
    firstsmooth = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,3);
 
    hsv_min = cvScalar(120, 10, 80, 0);    //HSV kleuren !
    hsv_max = cvScalar(150, 255, 255, 0); //kleur tussen 0 en 255
 
    return (VP_SUCCESS);
}
En de functie die wordt aangeroepen om het beeld op te bouwen en de bal te vinden:
C_RESULT output_rendering_device_stage_transform( void *cfg, vp_api_io_data_t *in, vp_api_io_data_t *out)
{
  int key;
  int i,j;
  int gevonden = 0; //bal gevonden ja of nee
  CvScalar pix,pix2;
  CvSeq* circles;
  CvMemStorage * storage;
  float *p;
 
  vlib_stage_decoding_config_t* vec = (vlib_stage_decoding_config_t*)cfg;
  vp_os_mutex_lock(&video_update_lock);
 
  /* Get a reference to the last decoded picture */
  pixbuf_data      = (uint8_t*)in->buffers[0];
 
 
  //DH
  frame->imageData = pixbuf_data;
 
  cvCopy(frame,frame2,NULL);                             //BGR to RGBs
      for(i=0;i<DRONE_VIDEO_MAX_HEIGHT/2;i++){
          for(j=0;j<DRONE_VIDEO_MAX_WIDTH/2;j++){
              pix = cvGet2D(frame,i,j);
              pix2.val[0]=pix.val[2];
              pix2.val[1]=pix.val[1];
              pix2.val[2]=pix.val[0];
              cvSet2D(frame2,i,j,pix2);
          }
      }
 
  /* Send the actual video resolution to the rendering module */
  D3DChangeTextureSize(vec->controller.width,vec->controller.height);
  /* Send video picture to the rendering module */
  D3DChangeTexture(pixbuf_data);
 
  //********************* BAL ZOEKEN ************************************************
  storage = cvCreateMemStorage(0); //storage voor cirkels
  cvSmooth(frame2,firstsmooth, CV_GAUSSIAN,5,5,0,0);        //Beeld 2 keer smoothen
  cvSmooth(firstsmooth,firstsmooth, CV_GAUSSIAN,5,5,0,0);
  //cvShowImage("firstsmooth", firstsmooth);//DEBUG
 
  cvCvtColor(frame,hsv_frame,CV_BGR2HSV);                //kleuren omzetten naar HSV
  cvInRangeS(hsv_frame,hsv_min,hsv_max,thresholded);    //thresholded berekenen
  //cvInRangeS(hsv_frame,hsv_min2,hsv_max2,thresholded2);
  //cvOr(thresholded,thresholded2,thresholded,NULL);            //2 thresholded waardes orren
  cvShowImage("thresh", thresholded);//DEBUG
  //TRIAL AND ERROR
  //cvDilate(thresholded,thresholded,0,1);    //eerst dilate om vakjes op te vullen
  cvErode(thresholded,thresholded,0,3);        //Erosion
  //cvDilate(thresholded,thresholded,0,2);    //en terug dilate
 
  cvSmooth(thresholded,thresholded, CV_GAUSSIAN,5,5,0,0); //zwart wit image nog eens smoothen voor cirkel algoritme
 
  circles = cvHoughCircles(thresholded,storage,CV_HOUGH_GRADIENT,2,300,80,40,20,200); //cirkels zoeken en in memory zetten
 
  for(i =0;i<circles->total;i++) //normaal hoop je dat hij maar 1 cirkel ziet, maar het kunnen er meerdere zijn
  {                                 //dus we moeten zelf checken of de cirkel geldig is adhv de vorige cirkel
    p = (float*)cvGetSeqElem(circles,0);
    x = p[0];        //x-positie bal
    y = p[1];        //y-positie bal
    radius = p[2];    //straal bal
    gevonden = 1;
    //bovestaande moet ik nog in een mutex zetten, zodat urbi de waardes niet kan lezen terwijl dit prog ze
    //aan het schrijven is
 
    cvCircle(frame2,cvPoint(cvRound(p[0]),cvRound(p[1])),cvRound(p[2]),CV_RGB(255,0,0),-1,8,0); //zet er rondje rond
    cvCircle(frame2,cvPoint(cvRound(p[0]),cvRound(p[1])),3,CV_RGB(0,255,0),-1,8,0);
  }
  if(gevonden==1)  visible = 1; //trukje om visible te kunnen checken
  else visible = 0;
  gevonden = 0;
  //********************* EINDE BAL ZOEKEN ******************************************
 
 
 
  cvShowImage("Camera",frame2);
  key = cvWaitKey(1);
  //END CUSTOM
 
  vp_os_mutex_unlock(&video_update_lock);
 
  return (VP_SUCCESS);
}

NOV6 sec

Code die Maarten kan gebruiken om er een URBI object van te maken, mits kleine aanpassingen:

Onderstaande zijn de globale variable die moeten bestaan:
IplImage* frame;
  IplImage* frame2;
  IplImage* hsv_frame;
  IplImage* thresholded;
  IplImage* thresholded2;
  IplImage* firstsmooth;
  CvSize size;
  CvScalar hsv_min;
  CvScalar hsv_max;
  CvScalar hsv_min2;
  CvScalar hsv_max2;
  //Globale variable voor maarten
  int x;
  int y;
  int visible;
  int radius;


Onderstaande moet in een initialisatie functie komen:
cvNamedWindow("Camera",CV_WINDOW_AUTOSIZE);//DH //venster maken voor video ff in weer te geven
    cvNamedWindow("thresh",CV_WINDOW_AUTOSIZE);//voor te kijken of kleur klopt
 
    size = cvSize(DRONE_VIDEO_MAX_WIDTH, DRONE_VIDEO_MAX_HEIGHT);
 
    frame = cvCreateImage(size,IPL_DEPTH_8U,3);//DH
    frame2 = cvCreateImage(size,IPL_DEPTH_8U,3);
    hsv_frame = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,3);
    thresholded = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
    thresholded2 = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
    firstsmooth = cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,3);
 
    hsv_min = cvScalar(120, 10, 80, 0);    //HSV kleuren !
    hsv_max = cvScalar(150, 255, 255, 0); //kleur tussen 0 en 255

Onderstaande moet dus de functie zijn die wordt aangeroepen met een pointer naar het beeld als argument:
void vindBal( pointerbeeld *in) //pointer naar het beeld noem ik hier even in
{
  int key;
  int i,j;
  int gevonden = 0; //bal gevonden ja of nee
  CvScalar pix,pix2;
  CvSeq* circles;
  CvMemStorage * storage;
  float *p;
 
  pixbuf_data      = (uint8_t*)in->buffers[0];
 
  //DH
  frame->imageData = pixbuf_data;
 
  cvCopy(frame,frame2,NULL);                             //BGR to RGBs
      for(i=0;i<DRONE_VIDEO_MAX_HEIGHT/2;i++){
          for(j=0;j<DRONE_VIDEO_MAX_WIDTH/2;j++){
              pix = cvGet2D(frame,i,j);
              pix2.val[0]=pix.val[2];
              pix2.val[1]=pix.val[1];
              pix2.val[2]=pix.val[0];
              cvSet2D(frame2,i,j,pix2);
          }
      }
 
  //********************* BAL ZOEKEN ************************************************
  storage = cvCreateMemStorage(0); //storage voor cirkels
  cvSmooth(frame2,firstsmooth, CV_GAUSSIAN,5,5,0,0);        //Beeld 2 keer smoothen
  cvSmooth(firstsmooth,firstsmooth, CV_GAUSSIAN,5,5,0,0);
  //cvShowImage("firstsmooth", firstsmooth);//DEBUG
 
  cvCvtColor(frame,hsv_frame,CV_BGR2HSV);                //kleuren omzetten naar HSV
  cvInRangeS(hsv_frame,hsv_min,hsv_max,thresholded);    //thresholded berekenen
  //cvInRangeS(hsv_frame,hsv_min2,hsv_max2,thresholded2);
  //cvOr(thresholded,thresholded2,thresholded,NULL);            //2 thresholded waardes orren
  cvShowImage("thresh", thresholded);//DEBUG
  //TRIAL AND ERROR
  //cvDilate(thresholded,thresholded,0,1);    //eerst dilate om vakjes op te vullen
  cvErode(thresholded,thresholded,0,3);        //Erosion
  //cvDilate(thresholded,thresholded,0,2);    //en terug dilate
 
  cvSmooth(thresholded,thresholded, CV_GAUSSIAN,5,5,0,0); //zwart wit image nog eens smoothen voor cirkel algoritme
 
  circles = cvHoughCircles(thresholded,storage,CV_HOUGH_GRADIENT,2,300,80,40,20,200); //cirkels zoeken en in memory zetten
 
  for(i =0;i<circles->total;i++) //normaal hoop je dat hij maar 1 cirkel ziet, maar het kunnen er meerdere zijn
  {                                 //dus we moeten zelf checken of de cirkel geldig is adhv de vorige cirkel
    p = (float*)cvGetSeqElem(circles,0);
    x = p[0];        //x-positie bal
    y = p[1];        //y-positie bal
    radius = p[2];    //straal bal
    gevonden = 1;
    //bovestaande moet ik nog in een mutex zetten, zodat urbi de waardes niet kan lezen terwijl dit prog ze
    //aan het schrijven is
 
    cvCircle(frame2,cvPoint(cvRound(p[0]),cvRound(p[1])),cvRound(p[2]),CV_RGB(255,0,0),-1,8,0); //zet er rondje rond
    cvCircle(frame2,cvPoint(cvRound(p[0]),cvRound(p[1])),3,CV_RGB(0,255,0),-1,8,0);
  }
  if(gevonden==1)  visible = 1; //trukje om visible te kunnen checken
  else visible = 0;
  gevonden = 0;
  //********************* EINDE BAL ZOEKEN ******************************************
 
 
 
  cvShowImage("Camera",frame2);
  key = cvWaitKey(1);
  //END CUSTOM
}

En dan nog in de functie om alles te sluiten: (2 vensterkes afbreken)
cvDestroyWindow("video");
cvDestroyWindow("thresh");


NOV7

Aanpassingen aan de code in file video_stage.c:

In de initialisatie:
hsv_min = cvScalar(0, 10, 80, 0);    //HSV kleuren !
hsv_max = cvScalar(30, 255, 255, 0); //kleur tussen 0 en 255
 
wordt:
hsv_min = cvScalar(0, 10, 80, 0);    //HSV kleuren !
hsv_max = cvScalar(30, 255, 255, 0); //kleur tussen 0 en 255
hsv_min2 = cvScalar(160, 10, 80, 0);
hsv_max2 = cvScalar(180, 255, 255, 0);

In de functie om de bal te vinden :

cvCvtColor(frame2,hsv_frame,CV_BGR2HSV);//kleuren omzetten naar HSV
cvInRangeS(hsv_frame,hsv_min,hsv_max,thresholded);//thresholded berekenen
 
wordt:
cvCvtColor(frame2,hsv_frame,CV_BGR2HSV);//kleuren omzetten naar HSV
cvInRangeS(hsv_frame,hsv_min,hsv_max,thresholded);//thresholded berekenen
cvInRangeS(hsv_frame,hsv_min2,hsv_max2,thresholded2);
cvOr(thresholded,thresholded2,thresholded,NULL);
Bij Maarten is het frame ipv frame2. Ook de 2 eerste smoothings op frame mogen weg gelaten worden.

En volgende:
storage = cvCreateMemStorage(0); //storage voor cirkels
moet in de initialisatie komen, anders zitten we met memory leak


Functie om bal te vinden ziet er nu zo uit:
C_RESULT output_rendering_device_stage_transform( void *cfg, vp_api_io_data_t *in, vp_api_io_data_t *out)
{
  int key;
  int i,j;
  int gevonden = 0; //bal gevonden ja of nee
  CvScalar pix,pix2;
 
  vlib_stage_decoding_config_t* vec = (vlib_stage_decoding_config_t*)cfg;
  vp_os_mutex_lock(&video_update_lock);
 
  /* Get a reference to the last decoded picture */
  pixbuf_data      = (uint8_t*)in->buffers[0];
 
 
  //DH
  frame->imageData = pixbuf_data;
 
  cvCopy(frame,frame2,NULL);                             //BGR to RGBs
      for(i=0;i<DRONE_VIDEO_MAX_HEIGHT/2;i++){
          for(j=0;j<DRONE_VIDEO_MAX_WIDTH/2;j++){
              pix = cvGet2D(frame,i,j);
              pix2.val[0]=pix.val[2];
              pix2.val[1]=pix.val[1];
              pix2.val[2]=pix.val[0];
              cvSet2D(frame2,i,j,pix2);
          }
      }
 
  //********************* BAL ZOEKEN ************************************************
 
  cvCvtColor(frame2,hsv_frame,CV_BGR2HSV);                //kleuren omzetten naar HSV
  cvInRangeS(hsv_frame,hsv_min,hsv_max,thresholded);    //thresholded berekenen
  cvInRangeS(hsv_frame,hsv_min2,hsv_max2,thresholded2);
  cvOr(thresholded,thresholded2,thresholded,NULL);
 
  cvShowImage("thresh", thresholded);//DEBUG
  cvErode(thresholded,thresholded,0,3);        //Erosion voor minder ruis
 
  cvSmooth(thresholded,thresholded, CV_GAUSSIAN,5,5,0,0); //zwart wit image nog eens smoothen voor cirkel algoritme
 
  circles = cvHoughCircles(thresholded,storage,CV_HOUGH_GRADIENT,2,300,80,40,20,200); //cirkels zoeken en in memory zetten
 
  for(i =0;i<circles->total;i++) //normaal hoop je dat hij maar 1 cirkel ziet, maar het kunnen er meerdere zijn
  {                                 //dus we moeten zelf checken of de cirkel geldig is adhv de vorige cirkel
    p = (float*)cvGetSeqElem(circles,0);
    g_dhx = p[0];        //x-positie bal
    g_dhy = p[1];        //y-positie bal
    g_dhradius = p[2];    //straal bal
    gevonden = 1;
    //bovestaande moet ik nog in een mutex zetten, zodat urbi de waardes niet kan lezen terwijl dit prog ze
    //aan het schrijven is
 
    //cvCircle(frame2,cvPoint(cvRound(p[0]),cvRound(p[1])),cvRound(p[2]),CV_RGB(255,0,0),-1,8,0); //zet er rondje rond
    cvCircle(frame2,cvPoint(cvRound(p[0]),cvRound(p[1])),3,CV_RGB(0,255,0),-1,8,0);
  }
  if(gevonden==1)  g_dhvisible = 1; //trukje om visible te kunnen checken
  else g_dhvisible = 0;
  gevonden = 0;
  //********************* EINDE BAL ZOEKEN ******************************************
 
 
 
  cvShowImage("Camera",frame2);
  key = cvWaitKey(1);
  //END CUSTOM
 
  vp_os_mutex_unlock(&video_update_lock);
 
  return (VP_SUCCESS);
}
 
 
 
 

NOV12

4 sliders toegevoegd waar de S en V waarde mee te regelen zijn van HSV.

Globale variable:
int g_slider_position1 = 150;        //Globale variable voor slider
int g_slider_position2 = 80;        //Globale variable voor slider
int g_slider_position3 = 255;        //Globale variable voor slider
int g_slider_position4 = 255;        //Globale variable voor slider
 
int minKleurS=150;
int minKleurV=80;
int maxKleurS = 255;
int maxKleurV = 255;
Bijkomende functies:
void onTrackbarSlide1(int pos){
    minKleurS = pos;
}
void onTrackbarSlide2(int pos){
    minKleurV = pos;
}
void onTrackbarSlide3(int pos){
    maxKleurS = pos;
}
void onTrackbarSlide4(int pos){
    maxKleurV = pos;
}
In de initialisatiefunctie:
//hsv_min = cvScalar(0, 50, 80, 0);    //HSV kleuren !  S=10
//hsv_max = cvScalar(30, 255, 255, 0); //kleur tussen 0 en 255
//hsv_min2 = cvScalar(160, 50, 80, 0);
//hsv_max2 = cvScalar(180, 255, 255, 0);
 
    cvCreateTrackbar("Svaluemin","Camera",&g_slider_position1,255,onTrackbarSlide1);//Slider aanmaken
    cvCreateTrackbar("Svaluemax","Camera",&g_slider_position3,255,onTrackbarSlide3);//Slider aanmaken
    cvCreateTrackbar("Vvaluemin","Camera",&g_slider_position2,255,onTrackbarSlide2);//Slider aanmaken
    cvCreateTrackbar("Vvaluemax","Camera",&g_slider_position4,255,onTrackbarSlide4);//Slider aanmaken
En in de vind-bal functie:
hsv_min = cvScalar(0, minKleurS, minKleurV, 0);    //HSV kleuren !
hsv_max = cvScalar(30, maxKleurS, maxKleurV, 0); //kleur tussen 0 en 255
hsv_min2 = cvScalar(140, minKleurS, minKleurV, 0);
hsv_max2 = cvScalar(180, maxKleurS, maxKleurV, 0);








MAA11

#include "cv.h"
#include "highgui.h"
#include "BlobResult.h"
 
#include <stdio.h>
 
void main(){
    printf("test\n");
 
 
 
 
    //video
    cvNamedWindow("video",CV_WINDOW_AUTOSIZE); //Voor video van boomgaard
    cvNamedWindow("Output verticaal",CV_WINDOW_AUTOSIZE);//sobel vert
    cvNamedWindow("Output horizontaal",CV_WINDOW_AUTOSIZE);//sobel hori
    cvNamedWindow("Output horizontaal open",CV_WINDOW_AUTOSIZE);//sobel hori
    cvNamedWindow("Output horizontaal open blurred",CV_WINDOW_AUTOSIZE);//sobel hori
    cvNamedWindow("thresholded",CV_WINDOW_AUTOSIZE);//thresholded
    cvNamedWindow("test",CV_WINDOW_AUTOSIZE);
 
    CvCapture *capture = cvCreateFileCapture("goed1.mp4");
    IplImage* frame,*outputgray,*outputhorizontaal,*outputverticaal,*outhorblur,*outhorbluropen,*thresholded,*displayedImage;
 
    frame = cvQueryFrame(capture); //input frame om outputverticaal te kunnen initialiseren
    CvSize size = cvSize(
        (int)cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_WIDTH),
        (int)cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_HEIGHT)
    );
    outputgray = cvCreateImage(size,frame->depth,1);     //Zelfde beeld maar grijs
    outputverticaal = cvCreateImage(size,frame->depth,1);//Voor verticale sobel
    outputhorizontaal = cvCreateImage(size,frame->depth,1);//Voor horizontale sobel
    outhorblur = cvCreateImage(size,frame->depth,1);//Voor horizontale sobel
    outhorbluropen = cvCreateImage(size,frame->depth,1);//Voor horizontale sobel en daarna open
    thresholded = cvCreateImage(size,frame->depth,1);
    displayedImage = cvCreateImage(size,frame->depth,1);
 
    //SOBEL Filter voor verticaal
    char vals[] = {
                    -1,4,-1,
                    -4,8,-4,
                    -1,4,-1
                    };
    CvMat rotmat;
    cvInitMatHeader(&rotmat,3,3,CV_8SC1,vals);
    //
    //SOBEL Filter voor horizontaal
    char vals2[] = {
                    -1,-4,-1,
                    4,8,4,
                    -1,-4,-1
                    };
    CvMat rotmat2;
    cvInitMatHeader(&rotmat2,3,3,CV_8SC1,vals2);
    //
 
    while(1)
    {
        frame = cvQueryFrame(capture); //input frame
        cvCvtColor(frame,outputgray,CV_BGR2GRAY); //Omvormen naar grijs
        cvFilter2D(outputgray,outputverticaal,&rotmat);//Conversie van inputframe naar outputverticaal, met masker rotmat
        cvFilter2D(outputgray,outputhorizontaal,&rotmat2);//Conversie van inputframe naar outputhorizontaal, met masker rotmat2
        cvMorphologyEx(outputhorizontaal,outhorbluropen,0,CV_SHAPE_RECT,CV_MOP_OPEN,1);//open doen op horizontaal beeld
        cvErode(outhorbluropen,outhorbluropen,CV_SHAPE_RECT,1);//eroderen
        //cvDilate(outhorbluropen,outhorbluropen,CV_SHAPE_RECT,2);
        cvSmooth(outhorbluropen,outhorblur,CV_MEDIAN,3);//laatste parameter is vakje dat je gaat blurren
        cvSmooth(outhorblur,outhorblur,CV_MEDIAN,3);//laatste parameter is vakje dat je gaat blurren
        cvSmooth(outhorblur,outhorblur,CV_MEDIAN,3);//laatste parameter is vakje dat je gaat blurren
        cvThreshold(outhorblur,thresholded,254,254,CV_THRESH_BINARY);//threshold
        //
 
        //
        if(!frame) break;
        cvShowImage("video",frame);                         //Toont horizontale output
        cvShowImage("Output verticaal",outputverticaal); //Toont verticale output
        cvShowImage("Output horizontaal",outputhorizontaal); //Toont horizontale output
        cvShowImage("Output horizontaal open",outhorbluropen); //Toont open
        cvShowImage("Output horizontaal open blurred",outhorblur); //Toont blurred
        cvShowImage("thresholded",thresholded); //Toont blurred
        cvShowImage("test",displayedImage); //Toont blurred
        char c = cvWaitKey(33);
        if(c==27) break;
    }
 
    cvReleaseCapture(&capture);
    cvDestroyWindow("video");
    cvDestroyWindow("Output verticaal");
    cvDestroyWindow("Output horizontaal");
    cvDestroyWindow("Output horizontaal open");
    cvDestroyWindow("Output horizontaal open blurred");
    cvDestroyWindow("thresholded");
    //
 
 
}

18MAA

#include "cv.h"
#include "highgui.h"
#include "BlobResult.h"
#include "math.h"
 
#include <stdio.h>
 
void main(){
    printf("test\n");
 
    //Voor houghtransform
    CvMemStorage* storage = cvCreateMemStorage(0);
    CvSeq* lines = 0;
    int i;
    //
 
 
 
 
    //video
    cvNamedWindow("video",CV_WINDOW_AUTOSIZE); //Voor video van boomgaard
    cvNamedWindow("Output verticaal",CV_WINDOW_AUTOSIZE);//sobel vert
    cvNamedWindow("Output horizontaal",CV_WINDOW_AUTOSIZE);//sobel hori
    //cvNamedWindow("Output horizontaal open",CV_WINDOW_AUTOSIZE);//sobel hori
    //cvNamedWindow("Output horizontaal open blurred",CV_WINDOW_AUTOSIZE);//sobel hori
    //cvNamedWindow("thresholded",CV_WINDOW_AUTOSIZE);//thresholded
    cvNamedWindow("AND",CV_WINDOW_AUTOSIZE);
 
    CvCapture *capture = cvCreateFileCapture("goed1.mp4");
    IplImage* frame,*outputgray,*outputhorizontaal,*outputverticaal,*outhorblur,*outhorbluropen,*thresholded,*displayedImage;
 
    frame = cvQueryFrame(capture); //input frame om outputverticaal te kunnen initialiseren
    CvSize size = cvSize(
        (int)cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_WIDTH),
        (int)cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_HEIGHT)
    );
    outputgray = cvCreateImage(size,frame->depth,1);     //Zelfde beeld maar grijs
    outputverticaal = cvCreateImage(size,frame->depth,1);//Voor verticale sobel
    outputhorizontaal = cvCreateImage(size,frame->depth,1);//Voor horizontale sobel
    outhorblur = cvCreateImage(size,frame->depth,1);//Voor horizontale sobel
    outhorbluropen = cvCreateImage(size,frame->depth,1);//Voor horizontale sobel en daarna open
    thresholded = cvCreateImage(size,frame->depth,1);
    displayedImage = cvCreateImage(size,frame->depth,1);
 
 
    //SOBEL Filter voor verticaal
    char vals[] = {
                    -1,4,-1,
                    -4,8,-4,
                    -1,4,-1
                    };
    CvMat rotmat;
    cvInitMatHeader(&rotmat,3,3,CV_8SC1,vals);
    //
    //SOBEL Filter voor horizontaal
    char vals2[] = {
                    -1,-4,-1,
                    4,8,4,
                    -1,-4,-1
                    };
    CvMat rotmat2;
    cvInitMatHeader(&rotmat2,3,3,CV_8SC1,vals2);
    //
 
    while(1)
    {
        frame = cvQueryFrame(capture); //input frame
        cvCvtColor(frame,outputgray,CV_BGR2GRAY); //Omvormen naar grijs
        cvFilter2D(outputgray,outputverticaal,&rotmat);//Conversie van inputframe naar outputverticaal, met masker rotmat
        cvFilter2D(outputgray,outputhorizontaal,&rotmat2);//Conversie van inputframe naar outputhorizontaal, met masker rotmat2
        cvErode(outputverticaal,outputverticaal,0,1);//horizontaal en verticaal eroden om kleine stukjes weg te hebben
        cvErode(outputhorizontaal,outputhorizontaal,0,1);//horizontaal en verticaal eroden om kleine stukjes weg te hebben
        cvThreshold(outputverticaal,outputverticaal,254,254,CV_THRESH_BINARY);//threshold
        cvThreshold(outputhorizontaal,outputhorizontaal,254,254,CV_THRESH_BINARY);//threshold
        cvAnd(outputverticaal, outputhorizontaal, displayedImage, NULL);//2 afbeeldingen bij elkaar optellen
        //cvErode(displayedImage,displayedImage,0,1);//
        //cvMorphologyEx(displayedImage,outhorbluropen,0,0,CV_MOP_CLOSE,3);//open doen op horizontaal beeld
        //cvErode(outhorbluropen,outhorbluropen,0,1);//eroderen
        ////cvDilate(outhorbluropen,outhorbluropen,0,1);//DH
        cvSmooth(displayedImage,displayedImage,CV_MEDIAN,3);//laatste parameter is vakje dat je gaat blurren
        cvSmooth(displayedImage,displayedImage,CV_MEDIAN,3);//laatste parameter is vakje dat je gaat blurren
        cvSmooth(displayedImage,displayedImage,CV_MEDIAN,3);//laatste parameter is vakje dat je gaat blurren
        //cvSmooth(outhorblur,outhorblur,CV_MEDIAN,3);//laatste parameter is vakje dat je gaat blurren
        //cvSmooth(outhorblur,outhorblur,CV_MEDIAN,3);//laatste parameter is vakje dat je gaat blurren
        //cvThreshold(outhorblur,thresholded,254,254,CV_THRESH_BINARY);//threshold
        //cvErode(thresholded,thresholded,0,2);//DH
        //cvDilate(thresholded,thresholded,0,2);//DH
        //
        //HOUGH
        IplImage* dst = cvCreateImage( cvGetSize(displayedImage), 8, 1 );//Hough
        IplImage* color_dst = cvCreateImage( cvGetSize(displayedImage), 8, 3 );//hough
        cvCanny( displayedImage, dst, 200, 250, 3 );//50,200
        cvCvtColor( dst, color_dst, CV_GRAY2BGR );
        lines = cvHoughLines2( dst,
                               storage,
                               CV_HOUGH_STANDARD,
                               1,
                               CV_PI/180,
                               30,//100
                               0,
                               0
                               );
 
        for( i = 0; i < MIN(lines->total,50); i++ )
        {
            float* line = (float*)cvGetSeqElem(lines,i);
            float rho = line[0];
            float theta = line[1];
            if((theta>0.3 && theta<1)||(theta>2 && theta<2.7)) //Alleen lijnen die onder een hoek staan groter dan 10 graden en kleiner dan 170
            {
                CvPoint pt1, pt2;
                double a = cos(theta), b = sin(theta);
                double x0 = a*rho, y0 = b*rho;
                pt1.x = cvRound(x0 + 1000*(-b));
                pt1.y = cvRound(y0 + 1000*(a));
                pt2.x = cvRound(x0 - 1000*(-b));
                pt2.y = cvRound(y0 - 1000*(a));
                cvLine( frame, pt1, pt2, CV_RGB(255,0,0), 3, 8 );
                printf("theta : %f\n",theta);//DEBUG
            }
        }
        cvNamedWindow( "Canny", 1 );
        cvShowImage( "Canny", color_dst );
 
        //
        if(!frame) break;
        cvShowImage("video",frame);                         //Toont horizontale output
        cvShowImage("Output verticaal",outputverticaal); //Toont verticale output
        cvShowImage("Output horizontaal",outputhorizontaal); //Toont horizontale output
        //cvShowImage("Output horizontaal open",outhorbluropen); //Toont open
        //cvShowImage("Output horizontaal open blurred",outhorblur); //Toont blurred
        //cvShowImage("thresholded",thresholded); //Toont blurred
        cvShowImage("AND",displayedImage); //Toont blurred
        char c = cvWaitKey(33);
        if(c==27) break;
    }
 
    cvReleaseCapture(&capture);
    cvDestroyWindow("video");
    cvDestroyWindow("Output verticaal");
    cvDestroyWindow("Output horizontaal");
    cvDestroyWindow("Output horizontaal open");
    cvDestroyWindow("Output horizontaal open blurred");
    cvDestroyWindow("thresholded");
    //
 
 
}







/* DH * */
/* * Thread waar later ons beeldverwerkings algorithme zal in komen ! */
/* * */
DEFINE_THREAD_ROUTINE( DH_test, nomParams )
{
C_RESULT res;
res = C_OK;

ardrone_at_set_led_animation ( SNAKE_GREEN_RED, 10, 5 ) API_WEAK; Led effectje starten

while(1)
{
ARWin32Demo_AcquireConsole(); Console opeisen om in te werken
ARWin32Demo_SetConsoleCursor(0,14); Cursor op rij 14 plaatsen
printf("Om deze regel af te printen draait er een apparte thread!.\n");
printf("ipv deze regel te printen kunnen we hier ons \n");
printf("beeldverwerkingsalgorithme in laten draaien.\n");
ARWin32Demo_ReleaseConsole(); Console terug vrijgeven voor de andere threads
}

THREAD_RETURN( res );
}
/* */
/* * */
#include "cv.h"
#include "highgui.h"
#include "BlobResult.h"
#include "math.h"

#include <stdio.h>

void main(){
printf("test\n");

Voor houghtransform
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* lines = 0;
int i;





video
cvNamedWindow("video",CV_WINDOW_AUTOSIZE);
Voor video van boomgaard
cvNamedWindow("Output verticaal",CV_WINDOW_AUTOSIZE);sobel vert
cvNamedWindow("Output horizontaal",CV_WINDOW_AUTOSIZE);
sobel hori
cvNamedWindow("Output horizontaal open",CV_WINDOW_AUTOSIZE);sobel hori
cvNamedWindow("Output horizontaal open blurred",CV_WINDOW_AUTOSIZE);sobel hori
cvNamedWindow("thresholded",CV_WINDOW_AUTOSIZE);thresholded
cvNamedWindow("AND",CV_WINDOW_AUTOSIZE);

CvCapture *capture = cvCreateFileCapture("goed1.mp4");
IplImage* frame,*outputgray,*outputhorizontaal,*outputverticaal,*outhorblur,*outhorbluropen,*thresholded,*displayedImage;

frame = cvQueryFrame(capture); input frame om outputverticaal te kunnen initialiseren
CvSize size = cvSize(
(int)cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_WIDTH),
(int)cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_HEIGHT)
);
outputgray = cvCreateImage(size,frame->depth,1);
Zelfde beeld maar grijs
outputverticaal = cvCreateImage(size,frame->depth,1);Voor verticale sobel
outputhorizontaal = cvCreateImage(size,frame->depth,1);
Voor horizontale sobel
outhorblur = cvCreateImage(size,frame->depth,1);Voor horizontale sobel
outhorbluropen = cvCreateImage(size,frame->depth,1);
Voor horizontale sobel en daarna open
thresholded = cvCreateImage(size,frame->depth,1);
displayedImage = cvCreateImage(size,frame->depth,1);


SOBEL Filter voor verticaal
char vals[] = {
-1,4,-1,
-4,8,-4,
-1,4,-1
};
CvMat rotmat;
cvInitMatHeader(&rotmat,3,3,CV_8SC1,vals);

SOBEL Filter voor horizontaal
char vals2[] = {
-1,-4,-1,
4,8,4,
-1,-4,-1
};
CvMat rotmat2;
cvInitMatHeader(&rotmat2,3,3,CV_8SC1,vals2);


while(1)
{
frame = cvQueryFrame(capture); input frame
cvCvtColor(frame,outputgray,CV_BGR2GRAY);
Omvormen naar grijs
cvFilter2D(outputgray,outputverticaal,&rotmat);Conversie van inputframe naar outputverticaal, met masker rotmat
cvFilter2D(outputgray,outputhorizontaal,&rotmat2);
Conversie van inputframe naar outputhorizontaal, met masker rotmat2
cvErode(outputverticaal,outputverticaal,0,1);horizontaal en verticaal eroden om kleine stukjes weg te hebben
cvErode(outputhorizontaal,outputhorizontaal,0,1);
horizontaal en verticaal eroden om kleine stukjes weg te hebben
cvThreshold(outputverticaal,outputverticaal,254,254,CV_THRESH_BINARY);threshold
cvThreshold(outputhorizontaal,outputhorizontaal,254,254,CV_THRESH_BINARY);
threshold
cvAnd(outputverticaal, outputhorizontaal, displayedImage, NULL);2 afbeeldingen bij elkaar optellen
cvErode(displayedImage,displayedImage,0,1);
cvMorphologyEx(displayedImage,outhorbluropen,0,0,CV_MOP_CLOSE,3);open doen op horizontaal beeld
cvErode(outhorbluropen,outhorbluropen,0,1);eroderen
cvDilate(outhorbluropen,outhorbluropen,0,1);DH
cvSmooth(displayedImage,displayedImage,CV_MEDIAN,3);laatste parameter is vakje dat je gaat blurren
cvSmooth(displayedImage,displayedImage,CV_MEDIAN,3);
laatste parameter is vakje dat je gaat blurren
cvSmooth(displayedImage,displayedImage,CV_MEDIAN,3);laatste parameter is vakje dat je gaat blurren
cvSmooth(outhorblur,outhorblur,CV_MEDIAN,3);laatste parameter is vakje dat je gaat blurren
cvSmooth(outhorblur,outhorblur,CV_MEDIAN,3);laatste parameter is vakje dat je gaat blurren
cvThreshold(outhorblur,thresholded,254,254,CV_THRESH_BINARY);threshold
cvErode(thresholded,thresholded,0,2);DH
cvDilate(thresholded,thresholded,0,2);DH

HOUGH
IplImage* dst = cvCreateImage( cvGetSize(displayedImage), 8, 1 );
Hough
IplImage* color_dst = cvCreateImage( cvGetSize(displayedImage), 8, 3 );hough
cvCanny( displayedImage, dst, 200, 250, 3 );
50,200
cvCvtColor( dst, color_dst, CV_GRAY2BGR );
lines = cvHoughLines2( dst,
storage,
CV_HOUGH_STANDARD,
1,
CV_PI/180,
30,100
0,
0
);

for( i = 0; i < MIN(lines->total,50); i++ )
{
float* line = (float*)cvGetSeqElem(lines,i);
float rho = line[0];
float theta = line[1];
if((theta>0.3 && theta<1)||(theta>2 && theta<2.7))
Alleen lijnen die onder een hoek staan groter dan 10 graden en kleiner dan 170
{
CvPoint pt1, pt2;
double a = cos(theta), b = sin(theta);
double x0 = a*rho, y0 = b*rho;
pt1.x = cvRound(x0 + 1000*(-b));
pt1.y = cvRound(y0 + 1000*(a));
pt2.x = cvRound(x0 - 1000*(-b));
pt2.y = cvRound(y0 - 1000*(a));
cvLine( frame, pt1, pt2, CV_RGB(255,0,0), 3, 8 );
printf("theta : %f\n",theta);DEBUG
}
}
cvNamedWindow( "Canny", 1 );
cvShowImage( "Canny", color_dst );


if(!frame) break;
cvShowImage("video",frame); Toont horizontale output
cvShowImage("Output verticaal",outputverticaal);
Toont verticale output
cvShowImage("Output horizontaal",outputhorizontaal); Toont horizontale output
cvShowImage("Output horizontaal open",outhorbluropen); Toont open
cvShowImage("Output horizontaal open blurred",outhorblur); Toont blurred
cvShowImage("thresholded",thresholded); Toont blurred
cvShowImage("AND",displayedImage);
Toont blurred
char c = cvWaitKey(33);
if(c==27) break;
}

cvReleaseCapture(&capture);
cvDestroyWindow("video");
cvDestroyWindow("Output verticaal");
cvDestroyWindow("Output horizontaal");
cvDestroyWindow("Output horizontaal open");
cvDestroyWindow("Output horizontaal open blurred");
cvDestroyWindow("thresholded");
//


}