Ejemplo n.º 1
0
void activeB()
{
    if (activeB2() == 1)
    {
        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check1)))
        {
            g_print("\nBouton niveau de gris activé!\n");
            greyscale();
        }
        else
            g_print("\nBouton niveau de gris désactivé\n");

        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check2)))
        {
            g_print("\nBouton réduction du bruit activé!\n");
            bruit();
        }
        else
            g_print("\nBouton réduction du bruit désactivé\n");

        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check3)))
        {
            g_print("\nBouton de binarisation activé\n");
            binarise();
        }
        else
            g_print("\nBouton de binarisation désactivé\n");
    }
    else
        g_print("\nTout les traitements d'images sont désactivés...\n");
}
Ejemplo n.º 2
0
void test_labelling_one_label()
{
    puts("Starts test_labelling_one_label\n");
    
    uint16_t width = 7, height = 7;
    
    uint8_t data[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    
    uint32_t ref[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    
    gray8i_t *img = gray8iallocwd(width, height, data);
    
    bini_t *bin = binarise(img, 50);
    
    labels_t *labels = label(bin);
    
    if (labels->count != 1)
    {
        printf("test_labelling_one_label failed : expected count %d but got %d\n", 1, labels->count);
        labelling_tests_failed++;
        labfree(labels);
        gray8ifree(img);
        binifree(bin);
        return;
    }
    
    int i = 0;
    
    for (i = 0; i < labels->len; i++)
    {
        if ((labels->data[i] != ref[i]))
        {
            printf("test_labelling_one_label failed : expected value %d but got %d on %d\n", ref[i], labels->data[i], i);
            labelling_tests_failed++;
            labfree(labels);
            gray8ifree(img);
            binifree(bin);
            return;
        }
    }
    
    puts("test_labelling_one_label passed\n");
    labelling_tests_passed++;
    labfree(labels);
    gray8ifree(img);
    binifree(bin);
}
void ColourToTrack::pinpoint(IplImage* image)
{
	addObjectToVideo(image,binarise(image));
}
/*
 * TODO: Maybe move toCheck in own function
 */
vector<PR::Object> PatternRecognitioner::segmentImage(Mat _img, int minObjSize) {

    vector<PR::Object> segments;

    // Get grey values
    cvtColor(_img, _img, CV_BGR2GRAY);

    // Binarise
    _img = binarise(_img,128);

    // Open to remove distortions
    _img = open(_img);


    //Prepare object matrix
    vector<vector<bool>> objectMatrix;
    for(int i = 0; i < _img.cols; i++){
        vector<bool> v;
        objectMatrix.push_back(v);
        for(int j = 0; j < _img.rows; j++){
            objectMatrix[i].push_back(false);
        }
    }

    vector<PR::Point> objectPoints;
    vector<PR::Point> toCheck;

    for(int y = 0; y < _img.rows; y++) {
        for (int x = 0; x < _img.cols; x++) {
            uchar inP = _img.at<uchar>(cv::Point(x, y));

            if(inP == 255)
                continue;

            if(objectMatrix[x][y])
                continue;

            objectMatrix[x][y] = true;
            objectPoints.clear();
            objectPoints.push_back(PR::Point(x,y));
            toCheck.clear();
            toCheck.push_back(PR::Point(x,y));

            for(int a = 0; a < toCheck.size(); a++){

                checkNeighbours(_img,objectMatrix,objectPoints,toCheck,a);

                /*for(int i = -1; i < 2; i++) {
                    for (int j = -1; j < 2; j++) {
                        if (i == 0 && j == 0)
                            continue;
                        if (toCheck[a].y + i < 0 || toCheck[a].x + j < 0)
                            continue;
                        if (toCheck[a].y + i >= _img.rows || toCheck[a].x + j >= _img.cols)
                            continue;

                        uchar inP = _img.at<uchar>(cv::Point(toCheck[a].x + j, toCheck[a].y + i));
                        if (inP == 255)
                            continue;

                        if (objectMatrix[toCheck[a].x + j][toCheck[a].y + i])
                            continue;

                        objectMatrix[toCheck[a].x + j][toCheck[a].y + i] = true;

                        objectPoints.push_back(PR::Point(toCheck[a].x+j,toCheck[a].y+i));

                        toCheck.push_back(PR::Point(toCheck[a].x+j, toCheck[a].y+i));
                    }
                }*/
            }

            if(objectPoints.size() < 1)
                continue;

            PR::Object obj = PR::Object(objectPoints);
            cout << "Added Object " << obj.getWidth() << "x" << obj.getHeight() << endl;
            segments.push_back(obj);

        }
    }

    vector<PR::Object> objects;

    // Filter out small objects
    for(int i = 0; i < segments.size(); i++){
        if(segments[i].getWidth() < _img.rows/(100/minObjSize) && segments[i].getHeight() < _img.cols/(100/minObjSize)){
            continue;
        }
        objects.push_back(segments[i]);
    }

    cout << "Found " << objects.size() << " objects!" << endl;

    // Order Objects by Y-position
    bool swapped = true;
    while(swapped){
        swapped = false;
        for(int j = 0; j < objects.size()-1; j++){
            PR::Object current = objects[j];
            if(objects[j].leftStart() > objects[j+1].leftStart()){
                objects[j] = objects[j+1];
                objects[j+1] = current;
                swapped = true;
            }
        }
    }

    segments.clear();

    int i;
    int del = 0;
    //Combine splitted elements of letters //Caution: So only one-line texts work //TODO: you can do that better
    for(i = 0; i < objects.size() - 1; i++){

        if(objects[i+1].leftStart() < objects[i].leftStart() + objects[i].getWidth() ){
            for(int z = 0; z < objects[i+1].points().size(); z++){
                objects[i].points().push_back(objects[i+1].points()[z]);
            }
            del = i+1;
            segments.push_back(objects[i]);
            i++;
            continue;
        }
        segments.push_back(objects[i]);
    }
    if(del != objects.size() - 1 || objects.size() == 1)
        segments.push_back(objects.back());

    cout << "Combined to " << segments.size() << " Objects!" << endl;

    return segments;
}