Referência ao ficheiro src/vapiMacro.c

#include <stdio.h>
#include <string.h>
#include "vapi.h"
#include "vapiLists.h"
#include "vapiMacro.h"
#include "vapiMacroBypass.h"
#include "vapiOperationsDefault.h"
#include "vapiOperationOptions.h"
#include "vapiTypes.h"
#include "vapiAux.h"
#include "vapiImagesAux.h"
#include "vapiMemory.h"
#include <highgui.h>
#include <gtk/gtk.h>
#include "vapiGtkImages.h"
#include "vapiGtkEventsMacros.h"
#include "vapiGtkAux.h"

Diagrama de dependências de inclusão para vapiMacro.c:

Ir para o código fonte deste ficheiro.

Funções
void	vapiApplyMacro (vMacroHeader *MacroHeader, vImages *Images, vBoolean ResetResult, vBoolean SaveSequence)
	Applies the macro on the images supplied.
void	vapiApplyMacroUntil (vMacroHeader *MacroHeader, vImages *Images, int Until)
	Applies the macro on the images supplied until the selected item.
void	vapiConditionalJump (vImages *Images, vOptions *Options, vMacroResult *PreviousResult)
	Analises the Decision Value and makes a jump if necessary. While the macro is being applyied, we can jump from one item to another. This function detects this and performs the jump, based on the PreviousResults.
void	vapiLoadMacro (vImages *Images, vOptions *options, vMacroResult *PreviousResult)
	This is an operation to load other macros inside a macro. It can load the mother (!) macro, creating infinite loops. Be careful.
void	vapiMacroAddItem (vMacro *Macro, vEffect *Operation, vOptions *Options)
	Appends a configured operation to the end of the macro.
void	vapiMacroAddItemPositioned (vMacro *Macro, vEffect *Operation, vOptions *Options, int position)
	inserts an item into the desired position.
int	vapiMacroCountElements (vMacro *Macro)
	Count the Number of elements of a macro.
void	vapiMacroDelete (vMacroHeader *MacroHeader)
	Frees the entire MacroHeader.
void	vapiMacroDeleteItem (vMacro *Macro, int Delete)
	deletes an operation from the macro.
int	vapiMacroGetMacroIndex (vMacro *Macro, const char *MacroName, int order)
	gets the number of the operation in wich a macro is called.
vMacroHeader *	vapiMacroNew (const char *MacroName)
	Create a New Macro.
vMacroItem *	vapiMacroSelectItem (vMacro *Macro, int Item)
	gets an item of the macro.
char *	vapiMacroTag (const char *previousMacroTag, int operationNumber)
	Generate the current macroTag. MacroTags are a way to identify macros called from within other macros.
void	vapiMacroToText (vMacro *Macro)
	Exports the Macro to text, performing a list of the operations that this Macro uses. it is printed to stdout.
void	vapiMacroUpdateComment (vMacroHeader *MacroHeader, const char *MacroComment)
	To update the comment field of a Macro.
void	vapiMacroUpdateName (vMacroHeader *MacroHeader, const char *MacroName)
	Updates the Macro Name.
void	vMacroItemFree (vMacroItem *Free)
	frees a Macro item. This is used in the function to delete an item.

---

Documentação das funções

void vapiApplyMacro	(	vMacroHeader *	MacroHeader,
		vImages *	Images,
		vBoolean	ResetResult,
		vBoolean	SaveSequence
	)

Applies the macro on the images supplied.

Parâmetros:

	Images	images handler
	SaveSequence	If it saves each operation's image output (true/false).
	ResetResult	If the result's structure should be reseted or not.

Definido na linha 91 do ficheiro vapiMacro.c.

Referências _vImages::Actual, _vMacroResult::End, gtkImActual, _vMacroResult::JumpTo, _vMacroHeader::Macro, _vMacroHeader::MacroName, _vMacroItem::Operation, _vMacroItem::Options, _vMacroHeader::PreviousResult, v_bypass_get(), v_printf(), v_stopby_get(), vapiApplyOperation(), vapiGtkImagesFastUpdateInterface(), vapiGtkMacroRunningTest(), vapiMacroCountElements(), vapiMacroSelectItem(), vapiResultCheckMacroTag(), vapiResultSetCurrentMacroTag(), vFALSE e vResultReset().

Referenciado por vapiCalibrateCameraGetConstant(), vapiGtkApplyMacroThread() e vapiLoadMacro().

{
        vMacroItem *Item;
        int i = 0, MacroSize;
        char *filename, *macroTag;
        MacroSize = vapiMacroCountElements (MacroHeader->Macro);
        if (MacroSize == 0)
        {
                return;
        }
        /*
         * Fazer Reset aos Resultados Memorizados, se existirem.
         */
        if (ResetResult)
        {
                vResultReset ((vMacroResult *) MacroHeader->PreviousResult);
        }
        macroTag = vapiResultCheckMacroTag (MacroHeader->PreviousResult);
        for (i = 0; i < MacroSize; i++)
        {
                if (!vapiGtkMacroRunningTest ())
                {
                        return;
                }
                if (!v_bypass_get (macroTag, i))
                {
                        continue;
                }
                vapiResultSetCurrentMacroTag (MacroHeader->PreviousResult,
                                              macroTag, i);
                if (MacroHeader->PreviousResult->End)
                {

                        MacroHeader->PreviousResult->End = vFALSE;
                        return;
                }
                Item = vapiMacroSelectItem (MacroHeader->Macro, i);
                vapiApplyOperation (Images, (vEffect *) Item->Operation,
                                    (vOptions *) Item->Options,
                                    MacroHeader->PreviousResult);
                if (v_stopby_get (macroTag, i))
                {
                        vapiGtkImagesFastUpdateInterface (Images->Actual,
                                                          gtkImActual);
                }
                if (SaveSequence)
                {
                        filename = v_printf ("%s_Operation_%d.jpg",
                                             MacroHeader->MacroName, i);
                        cvSaveImage (filename, Images->Actual);
                        free (filename);

                }
                if (MacroHeader->PreviousResult->JumpTo != -1)
                {
                        i = MacroHeader->PreviousResult->JumpTo - 1;
                        MacroHeader->PreviousResult->JumpTo = -1;
                        continue;
                }
        }
        free (macroTag);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiApplyMacroUntil	(	vMacroHeader *	MacroHeader,
		vImages *	Images,
		int	Until
	)

Applies the macro on the images supplied until the selected item.

Parâmetros:

Images

images handler

Definido na linha 214 do ficheiro vapiMacro.c.

Referências _vImages::Actual, _vMacroResult::End, gtkImActual, _vMacroResult::JumpTo, _vMacroHeader::Macro, _vMacroItem::Operation, _vMacroItem::Options, _vMacroHeader::PreviousResult, v_bypass_get(), v_stopby_get(), vapiApplyOperation(), vapiGtkImagesFastUpdateInterface(), vapiGtkMacroRunningTest(), vapiMacroCountElements(), vapiMacroSelectItem(), vapiResultCheckMacroTag(), vapiResultSetCurrentMacroTag() e vFALSE.

Referenciado por vapiGtkApplyMacroUntilThread() e vapiGtkMacroTablesApplyUntil().

{
        vMacroItem *Item;
        int i = 0, MacroSize;
        char *macroTag;

        MacroSize = vapiMacroCountElements (MacroHeader->Macro);
        if (MacroSize == 0)
        {
                return;
        }
        macroTag = vapiResultCheckMacroTag (MacroHeader->PreviousResult);
        for (i = 0; i < MacroSize; i++)
        {
                if (!vapiGtkMacroRunningTest ())
                {
                        return;
                }
                if (!v_bypass_get (macroTag, i))
                {
                        continue;
                }
                vapiResultSetCurrentMacroTag (MacroHeader->PreviousResult,
                                              macroTag, i);
                if (MacroHeader->PreviousResult->End)
                {
                        MacroHeader->PreviousResult->End = vFALSE;
                        return;
                }
                Item = vapiMacroSelectItem (MacroHeader->Macro, i);
                vapiApplyOperation (Images, (vEffect *) Item->Operation,
                                    (vOptions *) Item->Options,
                                    MacroHeader->PreviousResult);
                if (v_stopby_get (macroTag, i))
                {
                        vapiGtkImagesFastUpdateInterface (Images->Actual,
                                                          gtkImActual);
                }
                if (MacroHeader->PreviousResult->JumpTo != -1)
                {

                        i = MacroHeader->PreviousResult->JumpTo - 1;
                        MacroHeader->PreviousResult->JumpTo = -1;
                        continue;
                }
                if (i == Until)
                {
                        return;
                }
        }
        free (macroTag);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiConditionalJump	(	vImages *	Images,
		vOptions *	Options,
		vMacroResult *	PreviousResult
	)

Analises the Decision Value and makes a jump if necessary. While the macro is being applyied, we can jump from one item to another. This function detects this and performs the jump, based on the PreviousResults.

Definido na linha 268 do ficheiro vapiMacro.c.

Referências _vMacroResult::Decision, _vOptions::ints, _vMacroResult::JumpTo, v_debug e vFALSE.

{
        if (PreviousResult->Decision)
        {
                v_debug ("JUMP TO TRUE");
                PreviousResult->JumpTo = Options->ints[0];
                PreviousResult->Decision = vFALSE;

        }
        else
        {
                v_debug ("JUMP TO FALSE");
                PreviousResult->JumpTo = Options->ints[1];
        }
}

void vapiLoadMacro	(	vImages *	Images,
		vOptions *	options,
		vMacroResult *	PreviousResult
	)

This is an operation to load other macros inside a macro. It can load the mother (!) macro, creating infinite loops. Be careful.

Parâmetros:

PreviousResult

The previous has to be passed, because it will be used in the child macro.

Definido na linha 177 do ficheiro vapiMacro.c.

Referências _vOptions::CustomOptions, _vMacroHeader::Macro, _vMacroHeader::MacroName, _vMacroHeader::PreviousResult, v_error(), vapiApplyMacro() e vFALSE.

Referenciado por vapiAvailableEfects().

{
        vMacroHeader *originalMacroHeader, *tempMacroHeader;

        if (((vEffectOptions *) options->CustomOptions)->Macros == NULL)
        {
                v_error ("Macro Não seleccionada correctamente");
                return;
        }

        tempMacroHeader = malloc (sizeof (vMacroHeader));
        originalMacroHeader =
                ((vEffectOptions *) options->CustomOptions)->Macros;
        tempMacroHeader->Macro = originalMacroHeader->Macro;
        tempMacroHeader->MacroName = originalMacroHeader->MacroName;
        tempMacroHeader->PreviousResult = PreviousResult;
#ifdef VAPI_WITHOUT_INTERFACE
        vapiApplyMacro (tempMacroHeader, Images, vFALSE, vFALSE);
#else
        vapiApplyMacro (tempMacroHeader, Images, vFALSE, vFALSE);
#endif

        free (tempMacroHeader);

}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiMacroAddItem	(	vMacro *	Macro,
		vEffect *	Operation,
		vOptions *	Options
	)

Appends a configured operation to the end of the macro.

Parâmetros:

	Operation	The Operation to add
	Options	the options data
	Macro	the Macro (not the MacroHeader).

Definido na linha 46 do ficheiro vapiMacro.c.

Referências _vMacroItem::Operation, _vMacroItem::Options e v_list_append().

Referenciado por vapiCalibrateCameraCreateMacro(), vapiGtkMacroAppendItem() e vapiMacroFromXML().

{
        vMacroItem *MacroItem;

        MacroItem = malloc (sizeof (vMacroItem));
        MacroItem->Operation = Operation;
        MacroItem->Options = Options;
        v_list_append ((vList *) Macro, MacroItem);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiMacroAddItemPositioned	(	vMacro *	Macro,
		vEffect *	Operation,
		vOptions *	Options,
		int	position
	)

inserts an item into the desired position.

Parâmetros:

	Operation	The Operation to add
	Options	the options data
	position	The place where to add the new item.

Definido na linha 76 do ficheiro vapiMacro.c.

Referências _vMacroItem::Operation, _vMacroItem::Options, v_list_insert() e vapiMacroToText().

Referenciado por vapiGtkMacroInsertItem().

{
        vMacroItem *MacroItem;

        MacroItem = malloc (sizeof (vMacroItem));
        MacroItem->Operation = Operation;
        MacroItem->Options = Options;

        v_list_insert ((vList *) Macro, MacroItem, position);

        vapiMacroToText (Macro);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

int vapiMacroCountElements

(

vMacro *

Macro

)

Count the Number of elements of a macro.

Retorna:

the number of operations of a macro.

Definido na linha 57 do ficheiro vapiMacro.c.

Referências v_list_count_elements().

Referenciado por vapiApplyMacro(), vapiApplyMacroUntil(), vapiGtkMacroInsertItem(), vapiGtkMacroItemMoveDown(), vapiGtkMacroItemMoveToBottom(), vapiGtkMacroTableModel(), vapiMacroToText() e vapiMacroToXML().

{
        return v_list_count_elements ((vList *) Macro);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiMacroDelete

(

vMacroHeader *

MacroHeader

)

Frees the entire MacroHeader.

Definido na linha 205 do ficheiro vapiMacro.c.

Referências _vMacroHeader::Macro, _vMacroHeader::PreviousResult, v_list_free() e vMacroItemFree().

Referenciado por vapiCalibrateCameraGetConstant() e vapiMacroListDeleteItem().

{

        v_list_free (MacroHeader->Macro, (vFreeFunction *) & vMacroItemFree);
        free (MacroHeader->PreviousResult);
        free (MacroHeader);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiMacroDeleteItem	(	vMacro *	Macro,
		int	Delete
	)

deletes an operation from the macro.

Aviso:

It releases the options structure.

Parâmetros:

Delete

the number of the operation (in the macro) to delete

Definido na linha 63 do ficheiro vapiMacro.c.

Referências v_list_delete_item() e vMacroItemFree().

Referenciado por vapiGtkMacroDeleteItem().

{
        v_list_delete_item ((vList *) Macro,
                            (vFreeFunction *) & vMacroItemFree, Delete);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

int vapiMacroGetMacroIndex	(	vMacro *	Macro,
		const char *	MacroName,
		int	order
	)

gets the number of the operation in wich a macro is called.

Parâmetros:

	MacroName	The name of the macro that is called.
	order	the order of the call (if it is the first call, ou the n call).

Retorna:

the number of the item that makes the call (LoadMacro function). Returns -1 if the call does not exist.

Definido na linha 293 do ficheiro vapiMacro.c.

Referências _vChar::ch, _vOptions::chars, _vEffect::name, _vMacroItem::Operation, _vMacroItem::Options, v_list_count_elements() e v_list_get().

{

        int MacroSize, tempOrder = 0, i;
        vMacroItem *item;

        MacroSize = v_list_count_elements (Macro);

        for (i = 0; i < MacroSize; i++)
        {
                item = v_list_get (Macro, i);

                if (!strcmp (item->Operation->name, "Executar Tarefa"))
                {
                        if (!strcmp (item->Options->chars[0].ch, MacroName))
                        {
                                if (++tempOrder == order)
                                {
                                        return i;
                                }
                        }
                }
        }
        return -1;
}

Grafo de chamadas desta função:

vMacroHeader* vapiMacroNew

(

const char *

MacroName

)

Create a New Macro.

Ficheiro vapiMacroList.c

Trata da criação e gestão das Macros de macros para processar imagens.

Criado 28/11/2006

Definido na linha 31 do ficheiro vapiMacro.c.

Referências _vMacroHeader::Macro, _vMacroHeader::MacroComment, _vMacroHeader::MacroName, _vMacroHeader::PreviousResult, vapiMacroResultInit() e vapiReturnStringPointer().

Referenciado por vapiCalibrateCameraGetConstant(), vapiGtkMacroCreate() e vapiMacroFromXML().

{
        vMacroHeader *MacroHeader;
        vMacro *Macro = malloc (sizeof (vMacro));
        *Macro = NULL;
        MacroHeader = malloc (sizeof (vMacroHeader));
        MacroHeader->PreviousResult = vapiMacroResultInit ();
        MacroHeader->MacroName = vapiReturnStringPointer (MacroName);
        MacroHeader->Macro = Macro;
        MacroHeader->MacroComment = vapiReturnStringPointer ("");

        return MacroHeader;
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

vMacroItem* vapiMacroSelectItem	(	vMacro *	Macro,
		int	Item
	)

gets an item of the macro.

Retorna:

a pointer to the MacroItem.

Parâmetros:

Item

the number of the item to fetch.

Aviso:

the pointer can't be freed.

Definido na linha 70 do ficheiro vapiMacro.c.

Referências v_list_get().

Referenciado por vapiApplyMacro(), vapiApplyMacroUntil(), vapiGtkMacroSelectItem(), vapiGtkMacroSelectNext(), vapiGtkMacroTableModel(), vapiGtkMacroTablesApplyUntil(), vapiGtkMacroUpdateItemOptions(), vapiMacroToText() e vapiMacroToXML().

{
        return (v_list_get ((vList *) Macro, Item));
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

char* vapiMacroTag	(	const char *	previousMacroTag,
		int	operationNumber
	)

Generate the current macroTag. MacroTags are a way to identify macros called from within other macros.

Retorna:

A pointer to the macroTag string. This pointer must be freed when not used.

Definido na linha 334 do ficheiro vapiMacro.c.

Referências v_printf().

Referenciado por vapiGtkMacroTableAux() e vapiResultSetCurrentMacroTag().

{
        return v_printf ("%s:%d", previousMacroTag, operationNumber);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiMacroToText

(

vMacro *

Macro

)

Exports the Macro to text, performing a list of the operations that this Macro uses. it is printed to stdout.

Definido na linha 156 do ficheiro vapiMacro.c.

Referências vapiMacroCountElements() e vapiMacroSelectItem().

Referenciado por vapiMacroAddItemPositioned().

{
        vMacroItem *Item;
        int i, MacroSize;
        MacroSize = vapiMacroCountElements (Macro);

        for (i = 0; i < MacroSize; i++)
        {
                /*
                 * Carregar os dados do Operation.
                 */
                Item = vapiMacroSelectItem (Macro, i);

                /*
                 * Executar o Operation com os parâmetros definidos.
                 */

        }
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiMacroUpdateComment	(	vMacroHeader *	MacroHeader,
		const char *	MacroComment
	)

To update the comment field of a Macro.

Parâmetros:

Macrocomment

the comment to put in the Macro.

Definido na linha 320 do ficheiro vapiMacro.c.

Referências _vMacroHeader::MacroComment e vapiReturnStringPointer().

Referenciado por vapiGtkMacroChange(), vapiGtkMacroCreate() e vapiMacroFromXML().

{
        free (MacroHeader->MacroComment);
        MacroHeader->MacroComment = vapiReturnStringPointer (MacroComment);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vapiMacroUpdateName	(	vMacroHeader *	MacroHeader,
		const char *	MacroName
	)

Updates the Macro Name.

Parâmetros:

MacroName

The Macro's new name.

Definido na linha 327 do ficheiro vapiMacro.c.

Referências _vMacroHeader::MacroName e vapiReturnStringPointer().

Referenciado por vapiGtkMacroChange().

{
        free (MacroHeader->MacroName);
        MacroHeader->MacroName = vapiReturnStringPointer (MacroName);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

void vMacroItemFree

(

vMacroItem *

Free

)

frees a Macro item. This is used in the function to delete an item.

Definido na linha 286 do ficheiro vapiMacro.c.

Referências _vMacroItem::Operation, _vMacroItem::Options e vOperationOptionsFree().

Referenciado por vapiMacroDelete() e vapiMacroDeleteItem().

{
        vOperationOptionsFree (Free->Options, Free->Operation);
        free (Free);
}

Grafo de chamadas desta função:

Here is the caller graph for this function:

---