Substructure *MakeRecursiveSub(Substructure *sub, ULONG edgeLabel,
Parameters *parameters)
{
Substructure *recursiveSub;
// parameters used
Graph *posGraph = parameters->posGraph;
Graph *negGraph = parameters->negGraph;
recursiveSub = AllocateSub();
recursiveSub->definition = CopyGraph(sub->definition);
recursiveSub->recursive = TRUE;
recursiveSub->recursiveEdgeLabel = edgeLabel;
recursiveSub->instances =
GetRecursiveInstances(posGraph, sub->instances, sub->numInstances,
edgeLabel);
recursiveSub->numInstances = CountInstances(recursiveSub->instances);
if (negGraph != NULL)
{
recursiveSub->negInstances =
GetRecursiveInstances(negGraph, sub->negInstances,
sub->numNegInstances, edgeLabel);
recursiveSub->numNegInstances =
CountInstances(recursiveSub->negInstances);
}
EvaluateSub(recursiveSub, parameters);
return recursiveSub;
}
SubList *GetInitialSubs(Parameters *parameters)
{
SubList *initialSubs;
ULONG i, j;
ULONG vertexLabelIndex;
ULONG numInitialSubs;
Graph *g;
Substructure *sub;
Instance *instance;
// parameters used
Graph *posGraph = parameters->posGraph;
Graph *negGraph = parameters->negGraph;
LabelList *labelList = parameters->labelList;
ULONG outputLevel = parameters->outputLevel;
ULONG currentIncrement = 0;
ULONG startVertexIndex;
if (parameters->incremental)
{
currentIncrement = GetCurrentIncrementNum(parameters);
// Index for first vertex in increment
// Begin with the index for the first vertex in this increment and
// move up through all remaining vertices. Relies on the fact that
// each new increment is placed on the end of the vertex array and that
// we are only interested in the current (last) increment
startVertexIndex = GetStartVertexIndex(currentIncrement, parameters, POS);
if (parameters->outputLevel > 2)
printf("Start vertex index = %lu\n", startVertexIndex);
}
else
startVertexIndex = 0;
// reset labels' used flag
for (i = 0; i < labelList->numLabels; i++)
labelList->labels[i].used = FALSE;
numInitialSubs = 0;
initialSubs = AllocateSubList();
for (i = startVertexIndex; i < posGraph->numVertices; i++)
{
posGraph->vertices[i].TimesAddedToInstanceList = 0;
vertexLabelIndex = posGraph->vertices[i].label;
if (labelList->labels[vertexLabelIndex].used == FALSE)
{
labelList->labels[vertexLabelIndex].used = TRUE;
// create one-vertex substructure definition
g = AllocateGraph(1, 0);
g->vertices[0].label = vertexLabelIndex;
g->vertices[0].numEdges = 0;
g->vertices[0].edges = NULL;
g->vertices[0].TimesAddedToInstanceList = 0;
// allocate substructure
sub = AllocateSub();
sub->definition = g;
sub->instances = AllocateInstanceList();
// collect instances in positive graph
j = posGraph->numVertices;
do
{
j--;
if (posGraph->vertices[j].label == vertexLabelIndex)
{
// ***** do inexact label matches here? (instance->minMatchCost
// ***** too)
instance = AllocateInstance(1, 0);
instance->vertices[0] = j;
instance->mapping[0].v1 = 0;
instance->mapping[0].v2 = j;
instance->minMatchCost = 0.0;
InstanceListInsert(instance, sub->instances, FALSE);
sub->numInstances++;
}
} while (j > i);
// only keep substructure if more than one positive instance
if (sub->numInstances > 1)
{
if (negGraph != NULL)
{
// collect instances in negative graph
sub->negInstances = AllocateInstanceList();
j = negGraph->numVertices;
if (parameters->incremental)
startVertexIndex =
GetStartVertexIndex(currentIncrement, parameters, POS);
else
startVertexIndex = 0;
do
{
j--;
if (negGraph->vertices[j].label == vertexLabelIndex)
{
// ***** do inexact label matches here?
// ***** (instance->minMatchCost too)
instance = AllocateInstance(1, 0);
instance->vertices[0] = j;
instance->mapping[0].v1 = 0;
instance->mapping[0].v2 = j;
instance->minMatchCost = 0.0;
InstanceListInsert(instance, sub->negInstances, FALSE);
sub->numNegInstances++;
}
// We need to try all negative graph labels
} while (j > startVertexIndex);
}
EvaluateSub(sub, parameters);
// add to initialSubs
SubListInsert(sub, initialSubs, 0, FALSE, labelList);
numInitialSubs++;
}
else
{ // prune single-instance substructure
FreeSub(sub);
}
}
}
if (outputLevel > 1)
printf("%lu initial substructures\n", numInitialSubs);
return initialSubs;
}
Substructure *CreateSubFromInstance(Instance *instance, Graph *graph)
{
Substructure *newSub = AllocateSub();
newSub->definition = InstanceToGraph(instance, graph);
return newSub;
}
