public bool visitPoint(GeoPoint point)
{
z_sum += point.getDim() > 2 ? point.Z : 0.0;
z_count++;
return(true);
}
/** * Transforms a point into this SRS (modifying the input data). * * @param input * Point to transform into this SRS * @return * True if the transformation succeeded, false if not */ public abstract bool transformInPlace(GeoPoint input);
protected void applyTo(GeoPoint point)
{
point.setSpatialReference(this);
}
static void bufferLinesToLines(GeoShape input, double b, GeoShape output)
{
// buffering lines turns them into polygons
foreach (GeoPointList i in input.getParts())
{
GeoPointList part = i;
if (part.Count < 2)
{
continue;
}
GeoPointList new_part;
// collect all the shifted segments:
SegmentList segments;
foreach (GeoPoint j in part)
{
Vector3D p0 = j;
Vector3D p1 = *(j + 1);
Vector3D d = p1 - p0; d.Normalize();
Vector3D b0 = new Vector3D(p0.X + b * d.Y, p0.Y - b * d.X, p1.Z);
Vector3D b1 = new Vector3D(p1.X + b * d.Y, p1.Y - b * d.X, p1.Z);
segments.Add(new Segment(b0, b1));
}
// then intersect each pair of shifted segments to find the new verts:
foreach (Segment k in segments)
{
Segment s0 = k;
Segment s1 = *(k + 1); //(k+1) != segments.end()? *(k+1) : *segments.begin();
if (k == segments.begin())
{
GeoPoint first = new GeoPoint(s0.p0, part[0].getSRS());
first.setDim(part[0].getDim());
new_part.Add(first);
}
Vector3D isect;
if (getLineIntersection(s0, s1, out isect))
{
GeoPoint r = new GeoPoint(isect, part[0].getSRS());
r.setDim(part[0].getDim());
new_part.Add(r);
}
if (k == segments.end() - 2)
{
GeoPoint last = new GeoPoint(s1.p1, part[0].getSRS());
last.setDim(part[0].getDim());
new_part.Add(last);
}
}
if (new_part.Count > 1)
{
output.getParts().Add(new_part);
}
}
}
/** * Returns a point transformed into this SRS. * * @param input * Point to transform into this SRS * @return * Transformed point; or GeoPoint::invalid() upon failure */ public abstract GeoPoint transform(GeoPoint input);
static void bufferLinesToPolygons(GeoShape input, double b, GeoShape output)
{
// buffering lines turns them into polygons
foreach (GeoPointList i in input.getParts())
{
GeoPointList part = i;
if (part.Count < 2)
{
continue;
}
GeoPointList new_part;
// collect segments in one direction and then the other.
SegmentList segments;
foreach (GeoPoint j in part)
{
Vector3D p0 = j;
Vector3D p1 = *(j + 1);
Vector3D d = p1 - p0;
d.Normalize();
Vector3D b0 = new Vector3D(p0.X + b * d.Y, p0.Y - b * d.X, p1.Z);
Vector3D b1 = new Vector3D(p1.X + b * d.Y, p1.Y - b * d.X, p1.Z);
segments.Add(new Segment(b0, b1));
// after the last seg, add an end-cap:
if (j == part.end() - 2)
{
Vector3D b2 = new Vector3D(p1.X - b * d.Y, p1.Y + b * d.X, p1.Z);
segments.Add(new Segment(b1, b2));
}
}
// now back the other way:
foreach (GeoPoint j in part) //TODO IS IN REVERSE !!
{
Vector3D p0 = j;
Vector3D p1 = *(j + 1);
Vector3D d = p1 - p0;
d.Normalize();
Vector3D b0 = new Vector3D(p0.X + b * d.Y, p0.Y - b * d.X, p1.Z);
Vector3D b1 = new Vector3D(p1.X + b * d.Y, p1.Y - b * d.X, p1.Z);
segments.Add(new Segment(b0, b1));
// after the last seg, add an end-cap:
if (j == part.rend() - 2)
{
Vector3D b2 = new Vector3D(p1.X - b * d.Y, p1.Y + b * d.X, p1.z());
segments.Add(new Segment(b1, b2));
}
}
// then intersect each pair of segments to find the new verts:
foreach (Segment k in segments)
{
Segment s0 = k;
Segment s1 = (k + 1) != segments.end() ? *(k + 1) : *segments.begin();
Vector3D isect;
if (getLineIntersection(s0, s1, out isect))
{
GeoPoint r = new GeoPoint(isect, part[0].getSRS());
r.setDim(part[0].getDim());
new_part.Add(r);
}
}
if (new_part.Count > 2)
{
output.getParts().Add(new_part);
}
}
}
public override GeoPoint transform(GeoPoint input)
{ //usar MathTransform.transform matTransform es abstracta, necesito usar la concreta de cada caso, geografica, etc.
//la concreta me la da una factoria coordinateTransformationFactory.
throw new NotImplementedException();
}
override public FeatureList process(FeatureList input, FilterEnv env)
{
//first time through, establish a working SRS for output data.
if (workingSrs == null)
{
//first try to use the terrain SRS if so directed:
SpatialReference newOutSrs = UseTerrainSrs ? env.getTerrainSRS() : null;
if (newOutSrs == null)
{
//failing that, see if we have an SRS in a resource:
if (Srs == null && SrsScript != null)
{
//Console.WriteLine("Borrame" + SrsScript.getCode());
Srs = env.getSession().Resources.getSRS(SrsScript.getCode());
#if TODO_PH
ScriptResult r = env.getScriptEngine().run(SrsScript, env);
if (r.isValid())
{
Srs = (env.getSession().Resources.getSRS(r.asString()));
throw new NotImplementedException();
}
else
{
env.getReport().error(r.asString());
}
#endif
}
newOutSrs = Srs;
}
//set the "working" SRS that will be used for all features passing though this filter:
workingSrs = newOutSrs != null ? newOutSrs : env.getInputSRS();
//LOCALIZE points arround a local origin (the working extent's centroid)
if (workingSrs != null && Localize)
{
if (env.getCellExtent().getSRS().isGeographic() && env.getCellExtent().getWidth() > 179)
{
//NOP - no localization for big geog extent ... needs more thought perhaps
}
else
{
GeoPoint centroid0 = newOutSrs == null?
newOutSrs.transform(env.getCellExtent()).getCentroid()
: env.getCellExtent().getCentroid();
//we do want the localizer point on the surface if possible:
GeoPoint centroid = ClampToTerrain(centroid0, env);
if (centroid == null)
{
centroid = centroid0;
}
Mogre.Matrix4 localizer = new Mogre.Matrix4();
//For geocentric datasets, we need a special localizer matrix:
if (workingSrs.isGeocentric())
{
localizer = workingSrs.getEllipsoid().createGeocentricInvRefFrame(centroid);
localizer = localizer.Inverse();
}
//For projected datasets, just a simple translation
else
{
localizer.SetTrans(new Mogre.Vector3((float)centroid.X, (float)centroid.Y, (float)0.0));
}
workingSrs = workingSrs.cloneWithNewReferenceFrame(localizer);
}
}
}
//we have to assing the output SRS on each pass
if (workingSrs != null)
{
env.setOutputSRS(workingSrs);
}
return(base.process(input, env));
}
public bool visitPoint(GeoPoint p)
{
//p.setSpatialReference (p * mat);
p.setDim(3);
return(true);
}
protected virtual AttributedNodeList process(AttributedNodeList input, FilterEnv env)
{
Node result;
if (input.Count > 1)
{
result = new osg.Group();
for (AttributedNodeList.iterator i = input.begin(); i != input.end(); i++)
{
osg.Node node = i.get().getNode();
if (node != null)
{
if (getEmbedAttributes())
{
embedAttributes(node, i.get().getAttributes());
}
result.asGroup().addChild(node);
}
}
}
else if (input.Count == 1)
{
result = input[0].getNode();
if (getEmbedAttributes())
{
embedAttributes(result.get(), input[0].getAttributes());
}
}
else
{
return(new AttributedNodeList());
}
// if there are no drawables or external refs, toss it.
if (!GeomUtils.hasDrawables(result.get()))
{
return(AttributedNodeList());
}
// NEXT create a XFORM if there's a localization matrix in the SRS. This will
// prevent jittering due to loss of precision.
SpatialReference input_srs = env.getInputSRS();
if (env.getExtent().getArea() > 0 && !input_srs.getReferenceFrame().isIdentity())
{
Vector3D centroid = new Vector3D(0, 0, 0);
osg.Matrixd irf = input_srs.getInverseReferenceFrame();
osg.Vec3d centroid_abs = centroid * irf;
osg.MatrixTransform xform = new osg.MatrixTransform(irf);
xform.addChild(result);
result = xform;
if (getApplyClusterCulling() && input_srs.isGeocentric())
{
Vector3D normal = centroid_abs;
normal.normalize();
//osg.BoundingSphere bs = result.computeBound(); // force it
// radius = distance from centroid inside which to disable CC altogether:
//float radius = bs.radius();
//osg.Vec3d control_point = bs.center();
Vector3D control_point = centroid_abs;
GeoPoint env_cen = input_srs.transform(env.getCellExtent().getCentroid());
GeoPoint env_sw = input_srs.transform(env.getCellExtent().getSouthwest());
float radius = (env_cen - env_sw).length();
// dot product: 0 = orthogonal to normal, -1 = equal to normal
float deviation = -radius / input_srs.getEllipsoid().getSemiMinorAxis();
osg.ClusterCullingCallback ccc = new osg.ClusterCullingCallback();
ccc.set(control_point, normal, deviation, radius);
osg.Group cull_group = new osg.Group();
cull_group.setCullCallback(ccc);
cull_group.addChild(xform);
result = cull_group;
//osgGIS.notify(osg.NOTICE) << "CCC: radius = " << radius << ", deviation = " << deviation << std.endl;
//if ( getDrawClusterCullingNormals() == true )
//{
// //DRAW CLUSTER-CULLING NORMALS
// osg.Geode* geode = new osg.Geode();
// osg.Geometry* g = new osg.Geometry();
// osg.Vec3Array* v = new osg.Vec3Array(2);
// (*v)[0] = control_point; (*v)[1] = control_point + (normal*radius);
// g.setVertexArray( v );
// osg.Vec4Array* c = new osg.Vec4Array(1);
// (*c)[0] = osg.Vec4f( 0,1,0,1 );
// g.setColorArray( c );
// g.setColorBinding( osg.Geometry.BIND_OVERALL );
// g.addPrimitiveSet( new osg.DrawArrays( osg.PrimitiveSet.LINES, 0, 2 ) );
// geode.addDrawable( g );
// cull_group.addChild( geode );
//}
}
}
if (getCullBackfaces())
{
result.getOrCreateStateSet().setAttributeAndModes(new osg.CullFace(), osg.StateAttribute.ON);
}
if (getDisableLighting())
{
result.getOrCreateStateSet().setMode(GL_LIGHTING, osg.StateAttribute.OFF);
}
if (getLineWidth() > 0.0f)
{
result.getOrCreateStateSet().setAttribute(new osg.LineWidth(line_width), osg.StateAttribute.ON);
}
if (getPointSize() > 0.0f)
{
osg.Point point = new osg.Point();
point.setSize(point_size);
result.getOrCreateStateSet().setAttribute(point, osg.StateAttribute.ON);
}
if (getAlphaBlending())
{
osg.BlendFunc blend_func = new osg.BlendFunc();
//blend_func.setFunction( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
result.getOrCreateStateSet().setAttributeAndModes(blend_func, osg.StateAttribute.ON);
result.getOrCreateStateSet().setRenderingHint(osg.StateSet.TRANSPARENT_BIN);
}
if (getRasterOverlayScript())
{
ScriptResult r = env.getScriptEngine().run(getRasterOverlayScript(), env);
if (r.isValid())
{
RasterResource *raster = env.getSession().getResources().getRaster(r.asString());
if (raster)
{
osg.Image *image = NULL;
std.stringstream builder;
string cell_id = env.getProperties().getValue("compiler.cell_id", "");
if (cell_id.length() > 0)
{
builder << "r" << cell_id << ".jpg";
}
else
{
double x = env.getExtent().getCentroid().x();
double y = env.getExtent().getCentroid().y();
builder << std.setprecision(10) << "r" << x << "x" << y << ".jpg";
}
if (raster.applyToStateSet(result.getOrCreateStateSet(), env.getExtent(), getRasterOverlayMaxSize(), &image))
{
// Add this as a skin resource so the compiler can properly localize and deploy it.
image.setFileName(builder.str());
env.getResourceCache().addSkin(result.getOrCreateStateSet());
}
}
}
else
{
env.getReport().error(r.asString());
}
}
if (getOptimize())
{
//osgGIS.notice() << "[BuildNodes] Optimizing..." << std.endl;
osgUtil.Optimizer opt;
int opt_mask =
osgUtil.Optimizer.DEFAULT_OPTIMIZATIONS |
osgUtil.Optimizer.MERGE_GEODES |
osgUtil.Optimizer.TRISTRIP_GEOMETRY |
osgUtil.Optimizer.SPATIALIZE_GROUPS;
// disable texture atlases, since they mess with our shared skin resources and
// don't work correctly during multi-threaded building
opt_mask &= ~osgUtil.Optimizer.TEXTURE_ATLAS_BUILDER;
// I've seen this crash the app when dealing with certain ProxyNodes.
// TODO: investigate this later.
opt_mask &= ~osgUtil.Optimizer.REMOVE_REDUNDANT_NODES;
// integrate the optimizer hints:
opt_mask |= env.getOptimizerHints().getIncludedOptions();
opt_mask &= ~(env.getOptimizerHints().getExcludedOptions());
opt.optimize(result.get(), opt_mask);
GeometryCleaner cleaner;
cleaner.clean(result.get());
}
AttributedNodeList output;
output.push_back(new AttributedNode(result.get()));
return(output);
}