protected internal FilterState appendState(FilterState _state)
{
if (next_state != null)
{
next_state.appendState(_state);
}
else
{
next_state = _state;
}
return next_state;
}
internal protected FilterState appendState(FilterState _state)
{
if (next_state != null)
{
next_state.appendState(_state);
}
else
{
next_state = _state;
}
return(next_state);
}
public override FilterStateResult traverse(FilterEnv in_env)
{
FilterStateResult result = new FilterStateResult();
current_env = in_env.advance();
if (in_features.Count > 0)
{
out_nodes = filter.process(in_features, current_env);
}
else if (in_fragments.Count > 0)
{
out_nodes = filter.process(in_fragments, current_env);
}
else if (in_nodes.Count > 0)
{
out_nodes = filter.process(in_nodes, current_env);
}
FilterState next = getNextState();
if (next != null)
{
if (out_nodes.Count > 0)
{
if (next is NodeFilterState)
{
NodeFilterState state = (NodeFilterState)next;
state.push(out_nodes);
}
else if (next is CollectionFilterState)
{
CollectionFilterState state = (CollectionFilterState)next;
state.push(out_nodes);
}
out_nodes.Clear();
result = next.traverse(current_env);
}
else
{
result.set(FilterStateResult.Status.STATUS_NODATA, filter);
}
}
in_features.Clear();
in_fragments.Clear();
in_nodes.Clear();
return(result);
}
/**
* Instructs this state's Filter to process its input.
*
* @param env
* Runtime processing environment
*/
public override FilterStateResult traverse(FilterEnv in_env)
{
FilterStateResult result = new FilterStateResult();
// clone a new environment:
current_env = in_env.advance();
FeatureList output = filter.process(in_features, current_env);
FilterState next = getNextState();
if (next != null)
{
if (output.Count > 0)
{
if (next is FeatureFilterState)
{
FeatureFilterState state = (FeatureFilterState)next;
state.push(output);
}
else if (next is FragmentFilterState)
{
FragmentFilterState state = (FragmentFilterState)next;
state.push(output);
}
else if (next is NodeFilterState)
{
NodeFilterState state = (NodeFilterState)next;
state.push(output);
}
else if (next is CollectionFilterState)
{
CollectionFilterState state = (CollectionFilterState)next;
state.push(output);
}
result = next.traverse(current_env);
}
else
{
result.set(FilterStateResult.Status.STATUS_NODATA, filter);
}
}
// clean up
in_features.Clear();
return(result);
}
public override FilterStateResult signalCheckpoint()
{
#if TODO
FilterStateResult result;
FilterState next = getNextState();
if (next != null)
{
int metering = filter.getMetering();
if (next is FeatureFilterState)
{
if (features.Count > 0)
{
FeatureGroups feature_groups;
foreach (Feature i in features)
{
feature_groups[filter.assign(i, current_env)].Add(i);
}
FeatureFilterState state = (FeatureFilterState)next;
result = meterGroups(filter, feature_groups, state, metering, current_env);
}
else
{
result.set(FilterStateResult.Status.STATUS_NODATA, filter);
}
}
else if (next is FragmentFilterState)
{
FragmentFilterState state = (FragmentFilterState)next;
if (features.Count > 0)
{
FeatureGroups groups;
foreach (Feature i in features)
{
groups[filter.assign(i, current_env)].Add(i);
}
result = meterGroups(filter, groups, state, metering, current_env);
}
else if (fragments.Count > 0)
{
FragmentGroups groups;
foreach (Fragment i in fragments)
{
groups[filter.assign(i, current_env)].Add(i);
}
result = meterGroups(filter, groups, state, metering, current_env);
}
else
{
result.set(FilterStateResult.Status.STATUS_NODATA, filter);
}
}
else if (next is NodeFilterState)
{
NodeFilterState state = (NodeFilterState)next;
if (features.Count > 0)
{
FeatureGroups feature_groups;
foreach (Feature i in features)
{
feature_groups[filter.assign(i, current_env)].Add(i);
}
result = meterGroups(filter, feature_groups, state, metering, current_env);
}
else if (fragments.Count > 0)
{
FragmentGroups groups;
foreach (Fragment i in fragments)
{
groups[filter.assign(i, current_env)].Add(i);
}
result = meterGroups(filter, groups, state, metering, current_env);
}
else if (nodes.Count > 0)
{
NodeGroups groups;
foreach (AttributedNode i in nodes)
{
groups[filter.assign(i, current_env)].Add(i);
}
result = meterGroups(filter, groups, state, metering, current_env);
}
else
{
result.set(FilterStateResult.Status.STATUS_NODATA, filter);
}
}
else if (next is CollectionFilterState)
{
CollectionFilterState state = (CollectionFilterState)next;
if (features.Count > 0)
{
FeatureGroups feature_groups;
foreach (Feature i in features)
{
feature_groups[filter.assign(i, current_env)].Add(i);
}
result = meterGroups(filter, feature_groups, state, metering, current_env);
}
else if (fragments.Count > 0)
{
FragmentGroups groups;
foreach (Fragment i in fragments)
{
groups[filter.assign(i, current_env)].Add(i);
}
result = meterGroups(filter, groups, state, metering, current_env);
}
else if (nodes.Count > 0)
{
NodeGroups groups;
foreach (AttributedNode i in nodes)
{
groups[filter.assign(i, current_env)].Add(i);
}
result = meterGroups(filter, groups, state, metering, current_env);
}
else
{
result.set(FilterStateResult.Status.STATUS_NODATA, filter);
}
}
if (result.isOK())
{
result = next.signalCheckpoint();
}
}
// clean up the input:
features.Clear();
fragments.Clear();
nodes.Clear();
current_env = null;
return(result);
#endif
throw new NotImplementedException();
}
protected FilterState setNextState(FilterState _next_state)
{
//TODO: validate the the input filter is valid here
next_state = _next_state;
return(next_state);
}
/**
* Notifies this filter that a compilation checkpoint has been reached.
* This supports batching/metering of data by CollectionFilters.
*
* @return
* True if traversal succeeded, false upon error.
*/
public virtual FilterStateResult signalCheckpoint()
{
FilterState next = getNextState();
return(next != null?next.signalCheckpoint() : new FilterStateResult());
}
protected FilterState setNextState(FilterState _next_state)
{
//TODO: validate the the input filter is valid here
next_state = _next_state;
return next_state;
}
/**
* Runs the graph to generate a feature store. The graph should only
* contain FeatureFilter and CollectionFilter type filters.
*
* Executes the graph by passing features to the first filter in the
* chain. That filter will process the data, pass the results along to
* the next filter, and so on until completion.
*
* @param cursor
* Source cursor for features to process
* @param env
* Contextual compilation environment
* @param output_uri
* URI of a feature store to create and in which to store the results
* @return
* A structure describing the result of the compilation.
*/
public FilterGraphResult computeFeatureStore(FeatureCursor cursor, FilterEnv env, string output_uri)
{
#if TODO
bool ok = false;
// first build the filter state chain, validating that there are ONLY feature filters
// present. No other filter type is permitted when generating a feature store.
FilterState first = null;
foreach (Filter i in filter_prototypes)
{
Filter filter = i;
if (!(filter is FeatureFilter))
{
//TODO osgGIS.notify(osg.WARN) << "Error: illegal filter of type \"" << filter.getFilterType() << "\" in graph. Only feature features are allowed." << std.endl;
return(FilterGraphResult.error("Illegal first filter type in filter graph"));
}
FilterState next_state = filter.newState();
if (first == null)
{
first = next_state;
}
else
{
first.appendState(next_state);
}
}
if (first == null)
{
//TODO osgGIS.notify(osg.WARN) << "Error: filter graph \"" << getName() << "\" is empty." << std.endl;
return(FilterGraphResult.error("Illegal: empty filter graph"));
}
// next, append a WriteFeatures filter that will generate the output
// feature store.
WriteFeaturesFilter writer = new WriteFeaturesFilter();
writer.setOutputURI(output_uri);
//writer.setAppendMode( WriteFeaturesFilter.OVERWRITE );
FilterState output_state = writer.newState();
first.appendState(output_state);
// now run the graph.
FilterStateResult state_result;
int count = 0;
osg.Timer_t start = osg.Timer.instance().tick();
env.setOutputSRS(env.getInputSRS());
FeatureFilterState state = (FeatureFilterState)first;
while (state_result.isOK() && cursor.hasNext())
{
state.push(cursor.next());
state_result = state.traverse(env);
count++;
}
if (state_result.isOK())
{
state_result = state.signalCheckpoint();
}
osg.Timer_t end = osg.Timer.instance().tick();
double dur = osg.Timer.instance().delta_s(start, end);
if (state_result.isOK())
{
return(FilterGraphResult.ok(output_state.getLastKnownFilterEnv()));
}
else
{
return(FilterGraphResult.error("Filter graph failed to compute feature store"));
}
#endif
throw new NotImplementedException();
}
/**
* Runs the graph to generate a scene graph.
*
* Executes the graph by passing features to the first filter in the
* chain. That filter will process the data, pass the results along to
* the next filter, and so on until completion.
*
* @param cursor
* Source cursor for features to process
* @param env
* Contextual compilation environment
* @param output
* Group node that, upon success, contains resulting nodes of compiled scene
* as its children
* @return
* A structure describing the result of the compilation.
*/
public FilterGraphResult computeNodes(FeatureCursor cursor, FilterEnv env, osg.Group output)
{
FilterStateResult state_result;
output = null;
NodeFilterState output_state;
// first build a new state chain corresponding to our filter prototype chain.
FilterState first = null;
foreach (Filter i in filter_prototypes)
{
FilterState next_state = i.newState();
if (first == null)
{
first = next_state;
}
else
{
first.appendState(next_state);
}
if (next_state is NodeFilterState)
{
output_state = (NodeFilterState)next_state;
}
}
// now traverse the states.
if (first != null)
{
int count = 0;
osg.Timer_t start = osg.Timer.instance().tick();
env.setOutputSRS(env.getInputSRS());
if (first is FeatureFilterState)
{
FeatureFilterState state = (FeatureFilterState)first;
while (state_result.isOK() && cursor.hasNext())
{
state.push(wind(cursor.next()));
state_result = state.traverse(env);
count++;
}
if (state_result.isOK())
{
state_result = state.signalCheckpoint();
}
}
else if (first is FragmentFilterState)
{
FragmentFilterState state = (FragmentFilterState)first;
while (state_result.isOK() && cursor.hasNext())
{
state.push(wind(cursor.next()));
state_result = state.traverse(env);
count++;
}
if (state_result.isOK())
{
state_result = state.signalCheckpoint();
}
}
else if (first is CollectionFilterState)
{
CollectionFilterState state = (CollectionFilterState)first;
while (state_result.isOK() && cursor.hasNext())
{
state.push(wind(cursor.next()));
state_result = state.traverse(env);
count++;
}
if (state_result.isOK())
{
state_result = state.signalCheckpoint();
}
}
osg.Timer_t end = osg.Timer.instance().tick();
double dur = osg.Timer.instance().delta_s(start, end);
//osgGIS.notify( osg.ALWAYS ) << std.endl << "Time = " << dur << " s; Per Feature Avg = " << (dur/(double)count) << " s" << std.endl;
}
else
{
state_result.set(FilterStateResult.Status.STATUS_NODATA);
}
if (output_state != null && state_result.hasData())
{
output = new osg.Group();
foreach (AttributedNode i in output_state.getOutput())
{
output.addChild(i.getNode());
}
}
if (state_result.isOK())
{
return(FilterGraphResult.ok(output_state.getLastKnownFilterEnv()));
}
else
{
return(FilterGraphResult.error("Filter graph failed to compute any nodes"));
}
}