src/interface/vapiGtkEvents.c

Ir para a documentação deste ficheiro.

#include <gtk/gtk.h>
#include "vapiOperationsDefault.h"
#include "vapiAux.h"
#include "vapiImagesAux.h"
#include "vapiGtkAuxWindow.h"
#include <string.h>
#include "vapi.h"
#include "vapiCameraAcquisition.h"
#include "vapiMacro.h"
#include "vapiGtkInterface.h"
#include "vapiGtkAux.h"
#include "vapiGtkMemory.h"
#include "vapiMacroXML.h"
#include "vapiGtkOptions.h"
#include "vapiCameraCalibrate.h"
#include "vapiGtkCalibrateCamera.h"
#include "vapiCameraAcquisition.h"




/*
 * Guardar a Imagem
 */

void
vapiGtkSaveImage (GtkWidget * widget, vImages * Images)
{
        cvSaveImage ("save.jpg", Images->Actual);

}

void
vapiRefreshImageThread (GtkWidget * widget, vRefreshImage * RefreshImage)
{
        GError *Error;
        if (gtk_toggle_tool_button_get_active
            (GTK_TOGGLE_TOOL_BUTTON (RefreshImage->Temp->Widgets->cbCam)))
        {
                if (vapiCameraSettingsGetType
                    (RefreshImage->Temp->CameraSettings) == vCameraLocalFile)
                {
                        gtk_toggle_tool_button_set_active
                                (GTK_TOGGLE_TOOL_BUTTON
                                 (RefreshImage->Temp->Widgets->cbCam), FALSE);
                        return;
                }
                RefreshImage->STOP = 0;
                RefreshImage->CameraFeed =
                        g_thread_create ((GThreadFunc) vapiRefreshImage,
                                         RefreshImage, FALSE, &Error);
        }

}

void
vapiGtkCbLoadStaticImage (GtkWidget * widget, vapiTemp1Struct * temp)
{
        vImagesFreeImages (temp->Images);

        vapiGetSnapshot (temp->Images, temp->CameraSettings);
        vapiOriginal2Actual (temp->Images);
        vapiGtkPutImage (temp->Widgets->imOriginal, temp->Images->Original);
        vapiGtkPutImage (temp->Widgets->imActual, temp->Images->Actual);
        vapiGtkPutImage (temp->Widgets->imWork, temp->Images->Actual);
}

void
vapiGtkGetOriginal (GtkWidget * widget, vapiTemp1Struct * temp)
{
        vImagesFreeActual (temp->Images);
        vapiOriginal2Actual (temp->Images);
        vapiGtkPutImage (temp->Widgets->imActual, temp->Images->Actual);
        vapiGtkPutImage (temp->Widgets->imWork, temp->Images->Actual);

}

void
vapiGtkToolbarStyle (GtkWidget * widget, GtkWidget * toolbar)
{

        if (gtk_check_menu_item_get_active ((GtkCheckMenuItem *) widget))
        {

                gtk_toolbar_set_style ((GtkToolbar *) toolbar,
                                       GTK_TOOLBAR_BOTH);

        }
        else
        {
                gtk_toolbar_set_style ((GtkToolbar *) toolbar,
                                       GTK_TOOLBAR_ICONS);

        }
}

void
vapiGtkSaveWorkImage (GtkWidget * widget, vapiTemp1Struct * temp)
{
        if (temp->imWork == NULL)
        {
                return;
        }
        vImagesFreeActual (temp->Images);
        temp->Images->Actual = temp->imWork;

        temp->imWork = NULL;
        vapiGtkPutImage (temp->Widgets->imWork, temp->Images->Actual);
}

void
vapiGtkSelectROIActual (GtkWidget * widget,
                        GdkEventFocus * event, vapiTemp1Struct * temp)
{
        vEffect *Operation;
        vEffectSettings *OperationSettings;

        Operation =
                vapiGetOperationFromTxtOperation (temp->Widgets->txtOperation,
                                                  temp->OperationList);
        if (Operation == NULL)
        {
                goto NoNeed;
                return;
        }
        OperationSettings = Operation->OptionsSettings->CustomOptionsSettings;
        if (OperationSettings->NeedOfAuxImage == NoNeed)
        {
              NoNeed:
                gtk_widget_show_all (temp->Widgets->ImageWindow);
                vapiGtkPutImageNotScaled (temp->Widgets->imShowOriginalSize,
                                          temp->Images->Actual);
                gtk_window_position ((GtkWindow *) temp->Widgets->
                                     ImageWindow, GTK_WIN_POS_CENTER_ALWAYS);
                if (Operation == NULL)
                {
                        return;
                }

        }
        if (OperationSettings->NeedOfAuxImage == NeedRegion)
        {
                temp->GetCoordinates->Vertice[0].x = -1;
                temp->GetCoordinates->Vertice[0].y = -1;
                temp->GetCoordinates->Vertice[1].x = -1;
                temp->GetCoordinates->Vertice[1].y = -1;
                temp->GetCoordinates->Vertice[2].x = -1;
                temp->GetCoordinates->Vertice[2].y = -1;
                temp->GetCoordinates->Vertice[3].x = -1;
                temp->GetCoordinates->Vertice[3].y = -1;

                gtk_widget_show_all (temp->Widgets->ImageWindowSelectRegion);
                vapiGtkPutImageNotScaled (temp->Widgets->imSelectRegion,
                                          temp->Images->Actual);
                gtk_window_position ((GtkWindow *) temp->Widgets->
                                     ImageWindowTemplate,
                                     GTK_WIN_POS_CENTER_ALWAYS);
                return;

        }
        if (OperationSettings->NeedOfAuxImage == NeedTemplate)
        {
                temp->GetCoordinates->Vertice[0].x = -1;
                temp->GetCoordinates->Vertice[0].y = -1;
                temp->GetCoordinates->Vertice[1].x = -1;
                temp->GetCoordinates->Vertice[1].y = -1;
                gtk_statusbar_push ((GtkStatusbar *) temp->GetCoordinates->
                                    stTemplateWindow, 0, " ");

                gtk_widget_show_all (temp->Widgets->ImageWindowTemplate);
                vapiGtkPutImageNotScaled (temp->Widgets->imSelectTemplate,
                                          temp->Images->Actual);
                gtk_window_position ((GtkWindow *) temp->Widgets->
                                     ImageWindowTemplate,
                                     GTK_WIN_POS_CENTER_ALWAYS);
                return;
        }
}

void
vapiGtkGrabMouseLocation (GtkWidget * widget,
                          GdkDragContext * drag_context,
                          vapiGtkGetCoordinates * GetCoordinates)
{
        gtk_widget_get_pointer (widget,
                                &GetCoordinates->Vertice[0].x,
                                &GetCoordinates->Vertice[0].y);
        v_debug ("Coordendas do rato, %d %d",
                 GetCoordinates->Vertice[0].x, GetCoordinates->Vertice[0].y);
        gtk_statusbar_push ((GtkStatusbar *) GetCoordinates->
                            stTemplateWindow, 0,
                            g_strdup_printf
                            ("Vertice[0]: (%d,%d)",
                             GetCoordinates->
                             Vertice[0].x, GetCoordinates->Vertice[0].y));
}

gboolean
vapiGtkTemplateDrag (GtkWidget * widget,
                     GdkEventMotion * event,
                     vapiGtkGetCoordinates * GetCoordinates)
{
        vImages *tempImages;
        GdkModifierType mask;
        gdk_window_get_pointer (gtk_widget_get_parent_window (widget),
                                &GetCoordinates->Vertice[1].x,
                                &GetCoordinates->Vertice[1].y, &mask);
        if (mask != GDK_BUTTON1_MASK)
        {
                return FALSE;
        }

        tempImages =
                vapiGtkAuxActual2Work ((vImages *) GetCoordinates->Images);

        gtk_statusbar_push ((GtkStatusbar *) GetCoordinates->
                            stTemplateWindow, 1,
                            g_strdup_printf
                            ("Vertice[0]: (%d,%d), Vertice[1]: (%d,%d)",
                             GetCoordinates->Vertice[0].x,
                             GetCoordinates->Vertice[0].y,
                             GetCoordinates->Vertice[1].x,
                             GetCoordinates->Vertice[1].y));
        v_debug ("Coordendas do rato, %d %d",
                 GetCoordinates->Vertice[1].x, GetCoordinates->Vertice[1].y);
        cvRectangle (tempImages->Actual,
                     cvPoint (GetCoordinates->Vertice[0].x,
                              GetCoordinates->Vertice[0].y),
                     cvPoint (GetCoordinates->Vertice[1].x,
                              GetCoordinates->Vertice[1].y),
                     CV_RGB (255, 0, 0), 1, 8, 0);
        v_debug ("passou o rectangulo");
        vapiGtkPutImage ((GtkWidget *) GetCoordinates->
                         imSelectTemplate, tempImages->Actual);

        vImagesFreeActual (tempImages);
        free (tempImages);

        return FALSE;

}

void
vapiGtkSaveTemplate (GtkWidget * widget, vapiTemp1Struct * temp)
{
        int x, y, width, height;
        IplImage *template;
        vEffect *Operation;
        vEffectSettings *OperationSettings;
        GtkWidget *txtFilename;

        if (temp->GetCoordinates->Vertice[0].x < 0 ||
            temp->GetCoordinates->Vertice[0].y < 0 ||
            temp->GetCoordinates->Vertice[1].x < 0 ||
            temp->GetCoordinates->Vertice[1].y < 0)
        {
                return;
        }
        Operation =
                vapiGetOperationFromTxtOperation (temp->Widgets->txtOperation,
                                                  temp->OperationList);
        if (Operation == NULL)
        {
                return;
        }

        OperationSettings = Operation->OptionsSettings->CustomOptionsSettings;
        if (OperationSettings->NeedOfAuxImage != NeedTemplate)
        {
                return;
        }

        txtFilename =
                vapiGtkOptionsGetAssociatedWidget ("c0",
                                                   Operation->OptionsSettings,
                                                   &temp->Widgets->
                                                   OptionsData);
        /*
         * Por agora não foi definido uma variável que guardasse o caminho do 
         *  ficheiro porque aind não foi bem determinado como proceder com strings.
         */
        if (temp->GetCoordinates->Vertice[0].x <
            temp->GetCoordinates->Vertice[1].x)
        {
                x = temp->GetCoordinates->Vertice[0].x;
                width = temp->GetCoordinates->Vertice[1].x -
                        temp->GetCoordinates->Vertice[0].x;
        }
        else
        {
                x = temp->GetCoordinates->Vertice[1].x;
                width = temp->GetCoordinates->Vertice[0].x -
                        temp->GetCoordinates->Vertice[1].x;
        }
        if (temp->GetCoordinates->Vertice[0].y <
            temp->GetCoordinates->Vertice[1].y)
        {
                y = temp->GetCoordinates->Vertice[0].y;
                height = temp->GetCoordinates->Vertice[1].y -
                        temp->GetCoordinates->Vertice[0].y;
        }
        else
        {
                y = temp->GetCoordinates->Vertice[1].y;
                height = temp->GetCoordinates->Vertice[0].y -
                        temp->GetCoordinates->Vertice[1].y;
        }

        cvSetImageROI (temp->Images->Actual, cvRect (x, y, width, height));
        template =
                cvCreateImage (cvSize (width, height), IPL_DEPTH_8U,
                               temp->Images->Actual->nChannels);
        cvCopy (temp->Images->Actual, template, NULL);
        cvSaveImage (g_strdup_printf
                     ("%s.jpg",
                      gtk_entry_get_text ((GtkEntry *) temp->GetCoordinates->
                                          txtTemplateFilename)), template);
        cvReleaseImage (&template);
        cvResetImageROI (temp->Images->Actual);



        gtk_entry_set_text ((GtkEntry *) txtFilename, g_strdup_printf
                            ("%s.jpg",
                             gtk_entry_get_text ((GtkEntry *) temp->
                                                 GetCoordinates->
                                                 txtTemplateFilename)));
        /*
         * Reset a todas as coordenadas
         */
        temp->GetCoordinates->Vertice[0].x = -1;
        temp->GetCoordinates->Vertice[0].y = -1;
        temp->GetCoordinates->Vertice[1].x = -1;
        temp->GetCoordinates->Vertice[1].y = -1;
        gtk_widget_hide (temp->Widgets->ImageWindowTemplate);

}

void
vapiGtkSelectRegion (GtkWidget * widget,
                     GdkEventButton * event,
                     vapiGtkGetCoordinates * GetCoordinates)
{


        int i, j, lineThickness = 1;
        char *statusBarText;
        vImages *tempImages;
        tempImages =
                vapiGtkAuxActual2Work ((vImages *) GetCoordinates->Images);

        statusBarText = g_strdup_printf (" ");
        v_debug ("Select Region\n");
        if (event->button == 3)
        {
                for (i = 0; i < 3; i++)
                {
                        if (GetCoordinates->Vertice[i].x > 0
                            && GetCoordinates->Vertice[i + 1].x < 0)
                        {
                                GetCoordinates->Vertice[i].x = -1;
                                GetCoordinates->Vertice[i].y = -1;
                                --i;
                                break;

                        }

                        if (i > 0 && GetCoordinates->Vertice[i].x > 0)
                        {
                                cvLine (tempImages->Actual,
                                        GetCoordinates->Vertice[i - 1],
                                        GetCoordinates->Vertice[i],
                                        CV_RGB (255, 0, 0), lineThickness, 8,
                                        0);

                        }
                        if (i == 2 && GetCoordinates->Vertice[i + 1].x > 0)
                        {
                                GetCoordinates->Vertice[i + 1].x = -1;
                                GetCoordinates->Vertice[i + 1].y = -1;
                                break;
                        }
                }
                for (j = 0; j <= i; j++)
                {
                        statusBarText = g_strdup_printf
                                ("%s Vertice%d: (%d,%d)",
                                 statusBarText, j,
                                 GetCoordinates->Vertice[j].x,
                                 GetCoordinates->Vertice[j].y);
                }
                gtk_statusbar_push ((GtkStatusbar *) GetCoordinates->
                                    stSelectRegion, 0, statusBarText);
                goto putImage;
        }

        if (GetCoordinates->Vertice[3].x > 0)
        {
                GetCoordinates->Vertice[0].x = -1;
                GetCoordinates->Vertice[0].y = -1;
                GetCoordinates->Vertice[1].x = -1;
                GetCoordinates->Vertice[1].y = -1;
                GetCoordinates->Vertice[2].x = -1;
                GetCoordinates->Vertice[2].y = -1;
                GetCoordinates->Vertice[3].x = -1;
                GetCoordinates->Vertice[3].y = -1;
        }

        for (i = 0; i < 4; i++)
        {
                if (GetCoordinates->Vertice[i].x > 0)
                {
                        if (i > 0)
                        {
                                cvLine (tempImages->Actual,
                                        GetCoordinates->Vertice[i - 1],
                                        GetCoordinates->Vertice[i],
                                        CV_RGB (255, 0, 0), lineThickness, 8,
                                        0);
                        }
                        continue;
                }
                else
                {
                        gtk_widget_get_pointer (widget,
                                                &GetCoordinates->Vertice[i].x,
                                                &GetCoordinates->Vertice[i].
                                                y);
                        for (j = 0; j <= i; j++)
                        {
                                statusBarText = g_strdup_printf
                                        ("%s Vertice%d: (%d,%d)",
                                         statusBarText, j,
                                         GetCoordinates->Vertice[j].x,
                                         GetCoordinates->Vertice[j].y);
                        }
                        gtk_statusbar_push ((GtkStatusbar *) GetCoordinates->
                                            stSelectRegion, 0, statusBarText);
                        if (i > 0)
                        {
                                cvLine (tempImages->Actual,
                                        GetCoordinates->Vertice[i - 1],
                                        GetCoordinates->Vertice[i],
                                        CV_RGB (255, 0, 0), lineThickness, 8,
                                        0);
                        }
                        if (i == 3)
                        {
                                cvLine (tempImages->Actual,
                                        GetCoordinates->Vertice[i],
                                        GetCoordinates->Vertice[0],
                                        CV_RGB (255, 0, 0), lineThickness, 8,
                                        0);
                        }
                        break;
                }


        }

      putImage:
        vapiGtkPutImageNotScaled ((GtkWidget *) GetCoordinates->
                                  imSelectRegion, tempImages->Actual);
        vImagesFreeActual (tempImages);
        free (tempImages);

}

void
vapiGtkSaveSelectedRegion (GtkWidget * widget, vapiTemp1Struct * temp)
{
        GtkWidget *Coordinate;
        int i;
        vEffect *Operation;
        if (temp->GetCoordinates->Vertice[0].x < 0 ||
            temp->GetCoordinates->Vertice[0].y < 0 ||
            temp->GetCoordinates->Vertice[1].x < 0 ||
            temp->GetCoordinates->Vertice[1].y < 0 ||
            temp->GetCoordinates->Vertice[2].x < 0 ||
            temp->GetCoordinates->Vertice[2].y < 0 ||
            temp->GetCoordinates->Vertice[3].x < 0 ||
            temp->GetCoordinates->Vertice[3].y < 0)
        {
                return;
        }
        Operation =
                vapiGetOperationFromTxtOperation (temp->Widgets->txtOperation,
                                                  temp->OperationList);

        if (Operation == NULL)
        {
                return;
        }
        vapiGtkOptionsBlockEvents (&temp->Widgets->OptionsEvents);
        for (i = 0; i < 4; i++)
        {

                Coordinate =
                        vapiGtkOptionsGetAssociatedWidget
                        (g_strdup_printf ("d%d", i * 2),
                         Operation->OptionsSettings,
                         &temp->Widgets->OptionsData);
                gtk_spin_button_set_value ((GtkSpinButton *) Coordinate,
                                           temp->GetCoordinates->Vertice[i].
                                           x);
                Coordinate =
                        vapiGtkOptionsGetAssociatedWidget (g_strdup_printf
                                                           ("d%d", i * 2 + 1),
                                                           Operation->
                                                           OptionsSettings,
                                                           &temp->Widgets->
                                                           OptionsData);
                gtk_spin_button_set_value ((GtkSpinButton *) Coordinate,
                                           temp->GetCoordinates->Vertice[i].
                                           y);

        }
        vapiGtkOptionsUnBlockEvents (&temp->Widgets->OptionsEvents);


}

void
vapiGtkExpandersA (GtkWidget * widget,
                   vapiCalibrateCameraExpandersA * expandersA)
{
        if (widget != expandersA->exCalibrateAColour)
        {
                gtk_expander_set_expanded ((GtkExpander *) expandersA->
                                           exCalibrateAColour, FALSE);

        }
        if (widget != expandersA->exCalibrateAFilters)
        {
                gtk_expander_set_expanded ((GtkExpander *) expandersA->
                                           exCalibrateAFilters, FALSE);

        }
        if (widget != expandersA->exCalibrateADistance)
        {
                gtk_expander_set_expanded ((GtkExpander *) expandersA->
                                           exCalibrateADistance, FALSE);

        }

}
void
vapiGtkExpandersB (GtkWidget * widget,
                   vapiCalibrateCameraExpandersB * expandersB)
{
        if (widget != expandersB->exCalibrateBColour)
        {
                gtk_expander_set_expanded ((GtkExpander *) expandersB->
                                           exCalibrateBColour, FALSE);

        }
        if (widget != expandersB->exCalibrateBFilters)
        {
                gtk_expander_set_expanded ((GtkExpander *) expandersB->
                                           exCalibrateBFilters, FALSE);

        }
        if (widget != expandersB->exCalibrateBDistance)
        {
                gtk_expander_set_expanded ((GtkExpander *) expandersB->
                                           exCalibrateBDistance, FALSE);

        }

}

void
vapiGtkEventCalibrateCamera (GtkWidget * widget,
                             vapiCalibrateCameraCalculate *
                             CalibrateCameraCalculate)
{

        vapiGtkWindowCalibrateCameraGetImages (CalibrateCameraCalculate,
                                               vTRUE);
}

void
vapiGtkEventCalibrateCameraTestColourDefinitions (GtkWidget * widget,
                                                  vapiCalibrateCameraCalculate
                                                  * CalibrateCameraCalculate)
{

        vapiGtkWindowCalibrateCameraGetImages (CalibrateCameraCalculate,
                                               vFALSE);
}

void
showWidget (GtkWidget * widget1, GtkWidget * widget2)
{
        gtk_widget_show_all (widget2);
}

---