public void render2d(Project project, PictureBox picBox) { SharpMap.Map myMap = new SharpMap.Map(); foreach (BuildLayer layer in project.getLayers()) { Source source = layer.getSource(); BoundingBox envelope = new BoundingBox(-1000.0, -1000.0, 1000.0, 1000.0);//TODO FeatureDataSet ds = new FeatureDataSet(); source.DataSource.Open(); source.DataSource.ExecuteIntersectionQuery(envelope, ds); source.DataSource.Close(); FeatureDataTable features = (FeatureDataTable)ds.Tables[0]; string label = "Trace test:\n"; foreach (FeatureDataRow row in features) { foreach (Object item in row.ItemArray) label += " - " + item; label += "\n"; } setLabel(label); //Show map //Filters FilterGraph graph = project.getFilterGraph(source.getName()); if (graph != null) { foreach (FeatureFilter filter in graph.getFilters()) { //aplicar filtro segun el tipo Mogre.DefaultSceneManagerFactory dsmf = new DefaultSceneManagerFactory(); Mogre.SceneManager sm = dsmf.CreateInstance("scenemanager"); FilterEnv env = new FilterEnv(sm, "env"); foreach (MogreGis.Resource resource in project.getResources()) { env.getSession().Resources.addResource(resource); } FeatureList list = Feature.DataTableToList(features); filter.process(list, env); //falta devolver la lista y procesarla *************************************** } } SharpMap.Layers.VectorLayer myLayer = new SharpMap.Layers.VectorLayer(layer.getName()); myLayer.DataSource = source.DataSource; myMap.Layers.Add(myLayer); } myMap.Size = new Size(picBox.Width, picBox.Height); myMap.ZoomToExtents(); picBox.Image = myMap.GetMap(); this.map = myMap; }
public CellCompiler( string _cell_id, string _abs_output_uri, FeatureLayer layer, FilterGraph graph, float _min_range, float _max_range, FilterEnv env, ResourcePackager _packager, osgDB.Archive _archive, // =NULL, object user_data) : // =NULL ); base(_abs_output_uri, layer, graph, env) { packager = _packager; cell_id = _cell_id; abs_output_uri = _abs_output_uri; min_range = _min_range; max_range = _max_range; archive = _archive; //TODO: maybe the FilterEnv should just have one of these by default. SmartReadCallback smart = new SmartReadCallback(); smart.setMinRange(min_range); env.setTerrainReadCallback(smart); setUserData(_user_data); output_status = CellCompiler.OutputStatus.OUTPUT_UNKNOWN; }
protected virtual uint queueTasks(Profile profile, TaskManager task_man) { uint level = 0; foreach (MapLayerLevelOfDetail i in map_layer.getLevels()) { MapLayerLevelOfDetail level_def = i; string s = level.ToString(); FilterEnv cell_env = getSession().createFilterEnv(); cell_env.setExtent(map_layer.getAreaOfInterest()); //GeoExtent.infinite() ); cell_env.setTerrainNode(getTerrainNode()); cell_env.setTerrainSRS(getTerrainSRS()); foreach (Property prop in level_def.getEnvProperties()) { cell_env.setProperty(prop); } Task task = new CellCompiler(s, s, level_def.getFeatureLayer(), level_def.getFilterGraph(), level_def.getMinRange(), level_def.getMaxRange(), cell_env, null, null, null); task_man.queueTask(task); } return(level); }
public FeatureLayerCompiler( FeatureLayer _layer, FilterGraph _graph, FilterEnv _env) { layer = _layer; filter_graph = _graph; env = _env; }
public SpatialReference getOutputSRS(Session session, SpatialReference terrain_srs) { if (!grid_valid || output_srs == null) { if (levels.Count > 0 && levels[0].getFilterGraph() != null) { FilterEnv env = session.createFilterEnv(); env.setTerrainSRS(terrain_srs); FilterList filters = levels[0].getFilterGraph().getFilters(); for (int ind = filters.Count - 1; ind >= 0; ind--) //reverse iterator? { if (output_srs != null) { break; } Filter i = filters[ind]; if (i is TransformFilter) { TransformFilter xf = (TransformFilter)i; if (xf.getUseTerrainSRS()) { if (env.getTerrainSRS() != null) { this.output_srs = env.getTerrainSRS(); } } else if (xf.getSRS()) { this.output_srs = (SpatialReference)(xf.getSRS()); } else if (xf.getSRSScript()) { ScriptResult r = env.getScriptEngine().run(xf.getSRSScript(), env); if (r.isValid()) { this.output_srs = session.getResources().getSRS(r.asString()); } else { env.getReport().error(r.asString()); } } } } if (output_srs == null) // no reproject..assume input srs { this.output_srs = levels[0].getFeatureLayer().getSRS(); } } } return(output_srs); }
/** * Processes a batch of Feature objects. * * @param input * Batch of features to process. * @param env * Runtime processing environment. * @return * A collection of Feature instances. The default implementation * of this method just returns the input. */ public virtual FeatureList process(FeatureList input, FilterEnv env) { FeatureList output = new FeatureList(); foreach (Feature i in input) { FeatureList interim = process(i, env); output.InsertRange(output.Count, interim); } return output; }
public FeatureLayerCompiler( string _name, FeatureLayer _layer, FilterGraph _graph, FilterEnv _env) : base(_name) { layer = _layer; filter_graph = _graph; env = _env; }
/** * 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 void render3d(Project project, SceneManager sceneMgr) { SharpMap.Map myMap = new SharpMap.Map(); foreach (BuildLayer layer in project.getLayers()) { Source source = layer.getSource(); BoundingBox envelope = new BoundingBox(-1000.0, -1000.0, 1000.0, 1000.0);//TODO FeatureDataSet ds = new FeatureDataSet(); source.DataSource.Open(); source.DataSource.ExecuteIntersectionQuery(envelope, ds); source.DataSource.Close(); FeatureDataTable features = (FeatureDataTable)ds.Tables[0]; //El codigo del PFC //********************************************************************************************************** //Show map //Filters FilterGraph graph = project.getFilterGraph(source.getName()); if (graph != null) { graph.Successors(); FilterEnv env = new FilterEnv(sceneMgr, source.getName()); FeatureList list = Feature.DataTableToList(features); if (graph.getFilter(1) is FeatureFilter) { FeatureFilter filter = (FeatureFilter)graph.getFilter(1); FeatureList l = filter.process(list, env); } else if (graph.getFilter(1) is FragmentFilter) { FragmentFilter filter = (FragmentFilter)graph.getFilter(1); FragmentList l = filter.process(list, env); } } //********************************************************************************************************** } }
protected Task createQuadKeyTask(QuadKey key) { // construct a filter environment template to use for all tasks: FilterEnv cell_env = getSession().createFilterEnv(); cell_env.setTerrainNode(getTerrainNode()); cell_env.setTerrainSRS(getTerrainSRS()); string abs_path = createAbsPathFromTemplate("g" + key.toString()); Task task = null; MapLayerLevelOfDetail def = getDefinition(key.createParentKey(), map_layer); if (def != null) { cell_env.setInputSRS(def.getFeatureLayer().getSRS()); cell_env.setExtent(map_layer.getAreaOfInterest().getSRS().transform(key.getExtent())); cell_env.setProperty(new Property("compiler.cell_id", key.toString())); foreach (Property i in def.getEnvProperties()) { cell_env.setProperty(i); } task = new CellCompiler( key.toString(), abs_path, def.getFeatureLayer(), def.getFilterGraph(), def.getMinRange(), def.getMaxRange(), cell_env, def.getResourcePackager() ? def.getResourcePackager() : resource_packager.get(), getArchive(), def.getUserData()); // osgGIS.info() // << "Task: Key = " << key.toString() << ", LOD = " << key.getLOD() << ", Extent = " << key.getExtent().toString() // << " (w=" << key.getExtent().getWidth() << ", h=" << key.getExtent().getHeight() << ")" // << std.endl; } return(task); }
public override IEnumerable <Parameter> CreateParameters() { var parameters = new List <Parameter>(); parameters.Add(Power = new BypassParameter("CPwr", "Power", this, "Pwr", false)); parameters.Add(OscillatorsMix = new RealParameter("CMix", "Oscillators Mix", "Mix", 0, 1, 0.01)); parameters.Add(MasterVolume = new VolumeParameter("MVol", "Master Volume", false)); parameters.Add(Unison = new EnumParameter <EPowerStatus>("UPwr", "Unison", "Pwr", false)); OscillatorsMix.SetDefaultValue(0.5); parameters.AddRange(OscillatorA.CreateParameters("A")); parameters.AddRange(OscillatorB.CreateParameters("B")); parameters.AddRange(EnvelopeSound.CreateParameters("EM")); parameters.AddRange(FilterEnv.CreateParameters("EF")); parameters.AddRange(Filter.CreateParameters("F")); parameters.AddRange(Distortion.CreateParameters("D")); parameters.AddRange(LFOModifierA.CreateParameters("LA")); parameters.AddRange(LFOModifierB.CreateParameters("LB")); return(parameters); }
public ScriptResult run(Script script, Feature feature, FilterEnv env) { if (!string.IsNullOrWhiteSpace(script.Language) && !script.Language.ToLowerInvariant().Contains("python")) return new ScriptResult(script.Code); scope.SetVariable("feature", feature); scope.SetVariable("env", env); StringBuilder code = new StringBuilder(); foreach (Script sc in scripts) { code.Append(sc.Code); } code.Append(script.Code); ScriptSource source2 = engine.CreateScriptSourceFromString(code.ToString(), SourceCodeKind.AutoDetect); var res2 = source2.Execute(scope); return new ScriptResult(res2); }
public ScriptResult run(Script script, FilterEnv env) { return run(script, null, env); }
public void render2d(Project project, PictureBox picBox) { SharpMap.Map myMap = new SharpMap.Map(); foreach (BuildLayer layer in project.getLayers()) { Source source = layer.getSource(); BoundingBox envelope = new BoundingBox(-1000.0, -1000.0, 1000.0, 1000.0);//TODO FeatureDataSet ds = new FeatureDataSet(); source.DataSource.Open(); source.DataSource.ExecuteIntersectionQuery(envelope, ds); source.DataSource.Close(); FeatureDataTable features = (FeatureDataTable)ds.Tables[0]; string label = "Trace test:\n"; foreach (FeatureDataRow row in features) { foreach (Object item in row.ItemArray) { label += " - " + item; } label += "\n"; } setLabel(label); //Show map //Filters FilterGraph graph = project.getFilterGraph(source.getName()); if (graph != null) { foreach (FeatureFilter filter in graph.getFilters()) { //aplicar filtro segun el tipo Mogre.DefaultSceneManagerFactory dsmf = new DefaultSceneManagerFactory(); Mogre.SceneManager sm = dsmf.CreateInstance("scenemanager"); FilterEnv env = new FilterEnv(sm, "env"); foreach (MogreGis.Resource resource in project.getResources()) { env.getSession().Resources.addResource(resource); } FeatureList list = Feature.DataTableToList(features); filter.process(list, env); //falta devolver la lista y procesarla *************************************** } } SharpMap.Layers.VectorLayer myLayer = new SharpMap.Layers.VectorLayer(layer.getName()); myLayer.DataSource = source.DataSource; myMap.Layers.Add(myLayer); } myMap.Size = new Size(picBox.Width, picBox.Height); myMap.ZoomToExtents(); picBox.Image = myMap.GetMap(); this.map = myMap; }
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); }
// FragmentFilter overrides public override FragmentList process(FeatureList input, FilterEnv env) { FragmentList output = new FragmentList(); //cuidado con las entidades dentro del for int i = 0; Vector3 scale; Vector3 distanceScale; Vector3 mScale = new Vector3 (1,1,1); float lWidth = 1; if (Scale != null) { scale = Registry.instance().GetEngine("Python").run(Scale).asVec3(); } else { scale = new Vector3(1, 1, 1); } if (CoordScale != null) { distanceScale = Registry.instance().GetEngine("Python").run(CoordScale).asVec3(); } else { distanceScale = new Vector3(1, 1, 1); } if (LineWidth != null) { lWidth = Registry.instance().GetEngine("Python").run(LineWidth).asFloat(); } if (MaterialScale != null) { mScale = Registry.instance().GetEngine("Python").run(MaterialScale).asVec3(); } SceneNode nodeIni = point3d(env.getName(), i, 0, 0, 0, null, env.getSceneMgr()); #if ESCALA_NODO_INICIAL if (Scale != null) { nodeIni.SetScale(Registry.instance().GetEngine("Python").run(Scale).asVec3()); } if (coordScale != null) { Vector3 vec3 = Registry.instance().GetEngine("Python").run(Scale).asVec3(); nodeIni.SetPosition(nodeIni.Position.x * vec3.x, nodeIni.Position.y * vec3.y, nodeIni.Position.z * vec3.z); #if TRACE_BUILDGEOMFILTER System.Console.WriteLine("(" + n.Position.x + "," + n.Position.y + ")"); #endif } #endif Fragment fIni = new Fragment(nodeIni); output.Add(fIni); foreach (Feature feature in input) { //if type of features is Point if (feature.row.Geometry is SharpMap.Geometries.Point) { SharpMap.Geometries.Point p = (SharpMap.Geometries.Point)feature.row.Geometry; i++; SceneNode n = point3d(env.getName(), i, (float)p.X, (float)p.Y, 0, nodeIni, env.getSceneMgr()); n.SetScale(scale); n.SetPosition(n.Position.x * distanceScale.x, n.Position.y * distanceScale.y, n.Position.z * distanceScale.z); Fragment f = new Fragment(n); output.Add(f); } //if type of features is Polygon else if (feature.row.Geometry is SharpMap.Geometries.Polygon) { SharpMap.Geometries.Polygon polygon = (SharpMap.Geometries.Polygon)feature.row.Geometry; ManualObject polygonNode = null; if (polygonNode == null) { polygonNode = env.getSceneMgr().CreateManualObject(env.getName() + "Node_" + i); MaterialPtr material = MaterialManager.Singleton.Create("Test/ColourPolygon", ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME); material.GetTechnique(0).GetPass(0).VertexColourTracking = (int)TrackVertexColourEnum.TVC_AMBIENT; //Vector3 v = Registry.instance().GetEngine("Python").run(Color, feature, null).asVec3(); MogreTessellationCallbacks callback = new MogreTessellationCallbacks(polygonNode, Color, feature); if (nameMaterial != null) { callback.Material = nameMaterial; // "Test/ColourPolygon2"; callback.MaterialScale = mScale; } GLUtessellatorImpl Glu = (GLUtessellatorImpl)GLUtessellatorImpl.gluNewTess(); Glu.gluTessCallback(GLU.GLU_TESS_VERTEX, callback); Glu.gluTessCallback(GLU.GLU_TESS_BEGIN, callback); Glu.gluTessCallback(GLU.GLU_TESS_END, callback); Glu.gluTessCallback(GLU.GLU_TESS_ERROR, callback); Glu.gluTessCallback(GLU.GLU_TESS_COMBINE, callback); Glu.gluTessBeginPolygon(null); Glu.gluTessBeginContour(); int numVertices = polygon.ExteriorRing.NumPoints/*/10+1*/; int numValores = 3; double[][] data = new double[numVertices][]; for (int j = 0; j < numVertices; j++) { data[j] = new double[numValores]; } int k = 0; //1 polygon = N vertices foreach (SharpMap.Geometries.Point point in polygon.ExteriorRing.Vertices) { //if (k % 10 == 0) { data[k/*/10*/][0] = point.X; data[k/*/10*/][1] = point.Y; data[k/*/10*/][2] = 0; } k++; //SceneNode n = point3d(env.getName()+i+k, k + 10, (float)point.X * 10.0f, (float)point.Y * 10.0f, 0, nodeIni, env.getSceneMgr()); } for (int j = 0; j < data.GetLength(0); j++) { Glu.gluTessVertex(data[j], 0, new Vector3((float)(data[j][1] * distanceScale.y), (float)(data[j][2] * distanceScale.z), (float)(data[j][0] * distanceScale.x))); } Glu.gluTessEndContour(); Glu.gluTessNormal(0, 0, 1); Glu.gluTessEndPolygon(); nodeIni.AttachObject(polygonNode); } i++; } //if type of features is MultiPolygon else if (feature.row.Geometry is SharpMap.Geometries.MultiPolygon) { SharpMap.Geometries.MultiPolygon mp = (SharpMap.Geometries.MultiPolygon)feature.row.Geometry; // 1 MultiPolygon = N polygon foreach (SharpMap.Geometries.Polygon polygon in mp.Polygons) { ManualObject polygonNode = null; if (polygonNode == null) { polygonNode = env.getSceneMgr().CreateManualObject(env.getName() + "Node_" + i); MaterialPtr material = MaterialManager.Singleton.Create("Test/ColourPolygon", ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME); material.GetTechnique(0).GetPass(0).VertexColourTracking = (int)TrackVertexColourEnum.TVC_AMBIENT; //Vector3 v = Registry.instance().GetEngine("Python").run(Color, feature, null).asVec3(); MogreTessellationCallbacks callback = new MogreTessellationCallbacks(polygonNode, Color, feature); if (nameMaterial != null) { callback.Material = nameMaterial; // "Test/ColourPolygon2"; callback.MaterialScale = mScale; } GLUtessellatorImpl Glu = (GLUtessellatorImpl)GLUtessellatorImpl.gluNewTess(); Glu.gluTessCallback(GLU.GLU_TESS_VERTEX, callback); Glu.gluTessCallback(GLU.GLU_TESS_BEGIN, callback); Glu.gluTessCallback(GLU.GLU_TESS_END, callback); Glu.gluTessCallback(GLU.GLU_TESS_ERROR, callback); Glu.gluTessCallback(GLU.GLU_TESS_COMBINE, callback); Glu.gluTessBeginPolygon(null); Glu.gluTessBeginContour(); int numVertices = polygon.ExteriorRing.NumPoints; int numValores = 3; double[][] data = new double[numVertices][]; for (int j = 0; j < numVertices; j++) { data[j] = new double[numValores]; } int k = 0; //1 polygon = N vertices foreach (SharpMap.Geometries.Point point in polygon.ExteriorRing.Vertices) { data[k][0] = point.X; data[k][1] = point.Y; data[k][2] = 0; k++; //SceneNode n = point3d(env.getName(), i, (float)point.X, (float)point.Y, 0, nodeIni, env.getSceneMgr()); } for (int j = 0; j < data.GetLength(0); j++) { Glu.gluTessVertex(data[j], 0, new Vector3(((float)data[j][1]) * distanceScale.y, ((float)data[j][2]) * distanceScale.z, ((float)data[j][0]) * distanceScale.x)); } Glu.gluTessEndContour(); Glu.gluTessNormal(0, 0, 1); Glu.gluTessEndPolygon(); nodeIni.AttachObject(polygonNode); } i++; } } //if type of features is Line else if (feature.row.Geometry is SharpMap.Geometries.ILineal/*SharpMap.Geometries.LineString*/) { System.Collections.Generic.List<SharpMap.Geometries.ILineal> lineas = new System.Collections.Generic.List<SharpMap.Geometries.ILineal>(); if (feature.row.Geometry is SharpMap.Geometries.MultiLineString) { foreach (SharpMap.Geometries.LineString l in ((SharpMap.Geometries.MultiLineString)(feature.row.Geometry)).LineStrings) { lineas.Add(l); } } else { lineas.Add((SharpMap.Geometries.ILineal)(feature.row.Geometry)); } foreach (SharpMap.Geometries.ILineal line in lineas) { ManualObject lineNode = env.getSceneMgr().CreateManualObject("line" + i); //MaterialPtr material = MaterialManager.Singleton.Create(nameMaterial, //ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME); //material.GetTechnique(0).GetPass(0).VertexColourTracking = // (int)TrackVertexColourEnum.TVC_AMBIENT; //material.GetTechnique(0).GetPass(0).SetDepthBias(100); //material.GetTechnique(0).GetPass(0).LightingEnabled = false; int nSeg = 5; // Number of segments on the cap or join pieces BufferParameters param = new BufferParameters(nSeg, BufferParameters.BufferEndCapStyle.CapRound, BufferParameters.BufferJoinStyle.JoinRound, 2); IGeometryFactory<Coord> geometryFactory = new GeometryFactory<Coord>(new CoordSeqFac(new CoordFac(PrecisionModelType.DoubleFloating))); //IWktGeometryReader<Coord> reader = geometryFactory.WktReader; //string txt = feature.row.Geometry.AsText(); ILineString line1 = (ILineString)GeometryConverter.ToNTSGeometry((SharpMap.Geometries.LineString)line, geometryFactory); // (ILineString<Coord>)reader.Read(txt); IGeometry coordBuffer = line1.Buffer(lWidth, param); ICoordinateSequence coords = coordBuffer.Coordinates; //Vector3 v = Registry.instance().GetEngine("Python").run(Color, feature, null).asVec3(); MogreTessellationCallbacks callback = new MogreTessellationCallbacks(lineNode, Color, feature); if (nameMaterial != null) { callback.Material = nameMaterial; // "Test/ColourPolygon2"; callback.MaterialScale = mScale; } GLUtessellatorImpl Glu = (GLUtessellatorImpl)GLUtessellatorImpl.gluNewTess(); Glu.gluTessCallback(GLU.GLU_TESS_VERTEX, callback); Glu.gluTessCallback(GLU.GLU_TESS_BEGIN, callback); Glu.gluTessCallback(GLU.GLU_TESS_END, callback); Glu.gluTessCallback(GLU.GLU_TESS_ERROR, callback); Glu.gluTessCallback(GLU.GLU_TESS_COMBINE, callback); Glu.gluTessBeginPolygon(null); Glu.gluTessBeginContour(); foreach (Coord coord in coords) { double[] data = new double[] { coord.X * distanceScale.x, coord.Y * distanceScale.y, (double.IsNaN(coord.Z) ? 0 : coord.Z) * distanceScale.z }; Glu.gluTessVertex(data, 0, new Vector3((float)data[1], (float)data[2], (float)data[0])); } Glu.gluTessEndContour(); Glu.gluTessNormal(0, 0, 1); Glu.gluTessEndPolygon(); i++; nodeIni.AttachObject(lineNode); } if ((feature.row.Geometry is SharpMap.Geometries.Polygon) | (feature.row.Geometry is SharpMap.Geometries.MultiPolygon)) { Fragment f = new Fragment(nodeIni); output.Add(f); } } } i = 0;//breakpoint /*foreach (Fragment fragment in output) { fragment.Node.Scale(0,0,0); }*/ #if TODO // if features are arriving in batch, resolve the color here. // otherwise we will resolve it later in process(feature,env). is_batch = input.Count > 1; batch_feature_color = overall_color; if (is_batch && getColorScript() != null) { ScriptResult r = env.getScriptEngine().run(getColorScript(), env); if (r.isValid()) batch_feature_color = r.asVec4(); else env.getReport().error(r.asString()); } return base.process(input, env); #endif //throw new NotImplementedException(); if (successor != null) { if (successor is FeatureFilter) { FeatureFilter filter = (FeatureFilter)successor; FeatureList l = filter.process(input, env); //FeatureList l = successor.process(input, env); } else if (successor is FragmentFilter) { FragmentFilter filter = (FragmentFilter)successor; FragmentList l = filter.process(output, env); } } return output; }
public virtual void preMeter(FeatureList features, FilterEnv env) { }
/** * GeoPoint GeomUtils::clampToTerrain( const GeoPoint& input, osg::Node* terrain, SpatialReference* terrain_srs, SmartReadCallback* reader ) { GeoPoint output = GeoPoint::invalid(); if ( terrain && terrain_srs ) { double out_hat = 0; osg::ref_ptr<LineSegmentIntersector2> isector = createClampingIntersector( input, out_hat ); //GeoPoint p_world = terrain_srs->transform( input ); //osg::Vec3d clamp_vec; //osg::ref_ptr<osgUtil::LineSegmentIntersector> isector; //if ( terrain_srs->isGeocentric() ) //{ // clamp_vec = p_world; // clamp_vec.normalize(); // isector = new osgUtil::LineSegmentIntersector( // clamp_vec * terrain_srs->getEllipsoid().getSemiMajorAxis() * 1.2, // osg::Vec3d(0, 0, 0) ); //} //else //{ // clamp_vec.set(0, 0, 1); // osg::Vec3d ext_vec = clamp_vec * 1e6; // isector = new LineSegmentIntersector( // p_world + ext_vec, // p_world - ext_vec ); //} RelaxedIntersectionVisitor iv; iv.setIntersector( isector.get() ); iv.setReadCallback( reader ); //IntersectionVisitor iv; //iv.setIntersector( isector.get() ); //iv.setReadCallback( new SimpleReader() ); terrain->accept( iv ); if ( isector->containsIntersections() ) { output = GeoPoint( isector->getFirstIntersection().getWorldIntersectPoint(), terrain_srs ); } } * */ #endif private static GeoPoint ClampToTerrain(GeoPoint input, FilterEnv env) { //if (env.getTerrainNode() != null) //{ // //Falta por implementar GeomUtils.ClampToTerrain y env.getTerrainReadCallback. // //return GeomUtils.ClampToTerrain (input, env.getTerrainNode(), env.getTerrainSRS(),env.getTerrainReadCallback()); // return //} //else //{ return input; //} }
public virtual string assign(Fragment fragment, FilterEnv env) { return ""; }
// NodeFilter overrides protected virtual AttributedNodeList process(FragmentList input, FilterEnv env) { AttributedNodeList nodes; osg.Geode geode = null; for (FragmentList.const_iterator i = input.begin(); i != input.end(); i++) { Fragment frag = i; AttributeList frag_attrs = frag.getAttributes(); if (!geode) { geode = new osg.Geode(); nodes.Add(new AttributedNode(geode, frag_attrs)); } for (DrawableList.const_iterator d = frag.getDrawables().begin(); d != frag.getDrawables().end(); d++) { geode.addDrawable(d.get()); } bool retire_geode = false; // if a fragment name is set, apply it if (frag.hasName()) { geode.addDescription(frag.getName()); retire_geode = true; } if (getEmbedAttributes()) { embedAttributes(geode, frag_attrs); retire_geode = true; } // If required, reset the geode point so that the next fragment gets placed in a new geode. if (retire_geode) { geode = null; } } // with multiple geodes or fragment names, disable geode combining to preserve the node decription. if (nodes.Count > 1) { env.getOptimizerHints().exclude(osgUtil.Optimizer.MERGE_GEODES); } return process(nodes, env); }
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; }
public virtual string assign(Feature feature, FilterEnv env) { return ""; }
public virtual void preMeter(AttributedNodeList nodes, FilterEnv env) { }
public virtual void preMeter(FragmentList drawables, FilterEnv env) { }
/** * Runs the filter logic within the contextual environment, pushing the * filter's output to the next filter in the chain. * * @param env * Contextual compilation environment. * @return * True if traversal succeeded, false upon error. */ public abstract FilterStateResult traverse(FilterEnv env);
protected void applyFragmentName(Fragment frag, Feature feature, FilterEnv env) { if (getFeatureNameScript() != null) { ScriptResult r = env.getScriptEngine().run(getFeatureNameScript(), feature, env); if (r.isValid()) frag.setName(r.asString()); else env.getReport().error(r.asString()); } }
protected bool build(Source source, Session session) { //osgGIS.notice() << "Building source " << source.getName() << std.endl; // only need to build intermediate sources. if (!source.isIntermediate()) { //osgGIS.info() << "...source " << source.getName() << " does not need building (not intermediate)." << std.endl; return(true); } Source parent = source.getParentSource(); if (parent == null) { //osgGIS.warn() << "...ERROR: No parent source found for intermediate source \"" << source.getName() << "\"" << std.endl; return(false); } // check whether a rebuild is required: if (parent.getTimeLastModified() < source.getTimeLastModified()) { //osgGIS.info() << "...source " << source.getName() << " does not need building (newer than parent)." << std.endl; return(true); } // build it's parent first: if (!build(parent, session)) { //osgGIS.warn() << "...ERROR: Failed to build source \"" << parent.getName() << "\", parent of source \"" << source.getName() << "\"" << std.endl; return(false); } // validate the existence of a filter graph: FilterGraph graph = source.getFilterGraph(); if (graph == null) { //osgGIS.warn() << "...ERROR: No filter graph set for intermediate source \"" << source.getName() << "\"" << std.endl; return(false); } // establish a feature layer for the parent source: FeatureLayer feature_layer = Registry.instance().createFeatureLayer(parent.getAbsoluteURI()); if (feature_layer == null) { //osgGIS.warn() << "...ERROR: Cannot access source \"" << source.getName() << "\"" << std.endl; return(false); } //TODO: should we allow terrains for a source compile?? No. Because we would need to transform // the source into terrain SRS space, which we do not want to do until we're building nodes. // initialize a source data compiler. we use a temporary session because this source build // is unrelated to the current "master" build. If we used the same session, the new feature // store would hang around and not get properly closed out for use in the next round. Session temp_session = session.derive(); FilterEnv source_env = temp_session.createFilterEnv(); FeatureStoreCompiler compiler = new FeatureStoreCompiler(feature_layer, graph); if (!compiler.compile(source.getAbsoluteURI(), source_env)) { //osgGIS.warn() << "...ERROR: failure compiling source \"" << source.getName() << "\"" << std.endl; return(false); } //osgGIS.notice() << "...done compiling source \"" << source.getName() << "\"" << std.endl; return(true); }
override public FeatureList process(Feature input, FilterEnv env) { FeatureList output = new FeatureList(); //resolve the xlate shortcut Mogre.Matrix4 workingMatrix = Matrix; //TODO: this can go into process (FeatureList) instead of running for every feature.. if (TranslateScript != null) { ScriptResult r = env.getScriptEngine().run(TranslateScript, input, env); if (r.isValid()) { workingMatrix.MakeTrans(new Mogre.Vector3((float)r.asVec3().x, (float)r.asVec3().y, (float)r.asVec3().z)); } else { env.getReport().error(r.asString()); } } if (workingSrs != null || (workingMatrix != null && workingMatrix != Mogre.Matrix4.IDENTITY)) { //TODO foreach (Geometry shape in input.getGeometry()) //{ // if (workingMatrix != null && !workingMatrix.Equals(Mogre.Matrix4.IDENTITY)) // { // XformVisitor visitor = new XformVisitor(); // visitor.mat = workingMatrix; // shape.accept(visitor); // } // if (workingSrs != null && !(workingSrs.equivalentTo(env.getInputSRS()))) // { // workingSrs.transformInPlace(shape); // } //} if (workingSrs != null && !(workingSrs.equivalentTo(env.getInputSRS()))) { Geometry temp = GeometryTransform.TransformGeometry(input.getGeometry(), ((SharpMapSpatialReference)workingSrs).MathTransform); input.setGeometry(temp); //workingSrs.transformInPlace(input.getGeometry()); } } output.Add(input); return output; }
protected virtual Vector4D getColorForFeature(Feature input, FilterEnv env) { Vector4D result = overall_color; if (is_batch) { result = batch_feature_color; } else if (getColorScript() != null) { ScriptResult r = env.getScriptEngine().run(getColorScript(), input, env); if (r.isValid()) result = r.asVec4(); else env.getReport().error(r.asString()); } return result; }
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; }
public override FragmentList process(Feature input, FilterEnv env) { FragmentList output; // LIMITATION: this filter assumes all feature's shapes are the same // shape type! TODO: sort into bins of shape type and create a separate // geometry for each. Then merge the geometries. bool needs_tessellation = false; Fragment frag = new Fragment(); GeoShapeList shapes = input.getShapes(); #if TODO // if we're in batch mode, the color was resolved in the other process() function. // otherwise we still need to resolve it. Vector4D color = getColorForFeature(input, env); #endif #if TODO foreach (GeoShape s in shapes) { GeoShape shape = s; if (shape.getShapeType() == GeoShape.ShapeType.TYPE_POLYGON) { needs_tessellation = true; } osg.Geometry geom = new osg.Geometry(); // TODO: pre-total points and pre-allocate these arrays: osg.Vec3Array verts = new osg.Vec3Array(); geom.setVertexArray(verts); uint vert_ptr = 0; // per-vertex coloring takes more memory than per-primitive-set coloring, // but it renders faster. osg.Vec4Array colors = new osg.Vec4Array(); geom.setColorArray(colors); geom.setColorBinding(osg.Geometry.BIND_PER_VERTEX); //osg.Vec3Array* normals = new osg.Vec3Array(); //geom.setNormalArray( normals ); //geom.setNormalBinding( osg.Geometry.BIND_OVERALL ); //normals.push_back( osg.Vec3( 0, 0, 1 ) ); Mogre.PixelFormat prim_type = shape.getShapeType() == GeoShape.ShapeType.TYPE_POINT ? osg.PrimitiveSet.POINTS : shape.getShapeType() == GeoShape.ShapeType.TYPE_LINE ? osg.PrimitiveSet.LINE_STRIP : osg.PrimitiveSet.LINE_LOOP; #endif #if TODO for (int pi = 0; pi < shape.getPartCount(); pi++) { int part_ptr = vert_ptr; GeoPointList points = shape.getPart(pi); for (int vi = 0; vi < points.Count; vi++) { verts.Add(points[vi]); vert_ptr++; colors.Add(color); } geom.addPrimitiveSet(new osg.DrawArrays(prim_type, part_ptr, vert_ptr - part_ptr)); } // tessellate all polygon geometries. Tessellating each geometry separately // with TESS_TYPE_GEOMETRY is much faster than doing the whole bunch together // using TESS_TYPE_DRAWABLE. if (needs_tessellation) { osgUtil.Tessellator tess; tess.setTessellationType(osgUtil.Tessellator.TESS_TYPE_GEOMETRY); tess.setWindingType(osgUtil.Tessellator.TESS_WINDING_POSITIVE); tess.retessellatePolygons(*geom); applyOverlayTexturing(geom, input, env); } generateNormals(geom); frag.addDrawable(geom); } frag.addAttributes(input.getAttributes()); applyFragmentName(frag, input, env); output.Add(frag); return output; #endif throw new NotImplementedException(); }
public virtual string assign(AttributedNode attr, FilterEnv env) { return ""; }
protected void applyOverlayTexturing(osg.Geometry geom, Feature input, FilterEnv env) { GeoExtent tex_extent; if (getRasterOverlayScript() != null) { // if there's a raster script for this filter, we're applying textures per-feature: tex_extent = new GeoExtent( input.getExtent().getSouthwest().getAbsolute(), input.getExtent().getNortheast().getAbsolute()); } else { // otherwise prepare the geometry for an overlay texture covering the entire working extent: tex_extent = env.getExtent(); } float width = (float)tex_extent.getWidth(); float height = (float)tex_extent.getHeight(); // now visit the verts and calculate texture coordinates for each one. osg.Vec3Array verts = (osg.Vec3Array)(geom.getVertexArray()); if (verts != null) { // if we are dealing with geocentric data, we will need to xform back to a real // projection in order to determine texture coords: GeoExtent tex_extent_geo; if (env.getInputSRS().isGeocentric()) { tex_extent_geo = new GeoExtent( tex_extent.getSRS().getGeographicSRS().transform(tex_extent.getSouthwest()), tex_extent.getSRS().getGeographicSRS().transform(tex_extent.getNortheast())); } osg.Vec2Array texcoords = new osg.Vec2Array(verts.size()); for (int j = 0; j < verts.size(); j++) { // xform back to raw SRS w.o. ref frame: GeoPoint vert = new GeoPoint(verts[j], env.getInputSRS()); GeoPoint vert_map = vert.getAbsolute(); float tu, tv; if (env.getInputSRS().isGeocentric()) { tex_extent_geo.getSRS().transformInPlace(vert_map); tu = (vert_map.X - tex_extent_geo.getXMin()) / width; tv = (vert_map.Y - tex_extent_geo.getYMin()) / height; } else { tu = (vert_map.X - tex_extent.getXMin()) / width; tv = (vert_map.Y - tex_extent.getYMin()) / height; } (*texcoords)[j].set(tu, tv); } geom.setTexCoordArray(0, texcoords); } // if we are applying the raster per-feature, do so now. // TODO: deprecate? will we ever use this versus the BuildNodesFilter overlay? maybe if (getRasterOverlayScript() != null) { ScriptResult r = env.getScriptEngine().run(getRasterOverlayScript(), input, env); if (r.isValid()) { RasterResource raster = env.getSession().getResources().getRaster(r.asString()); if (raster != null) { Image image = null; std.stringstream builder; builder << "rtex_" << input.getOID() << ".jpg"; //TODO: dds with DXT1 compression osg.StateSet raster_ss = new osg.StateSet(); if (raster.applyToStateSet(raster_ss.get(), tex_extent, getRasterOverlayMaxSize(), out image)) { image.setFileName(builder.str()); geom.setStateSet(raster_ss.get()); // add this as a skin resource so the compiler can properly localize and deploy it. env.getResourceCache().addSkin(raster_ss.get()); } } } else { env.getReport().error(r.asString()); } } }
override public FeatureList process(FeatureList input, FilterEnv env) { foreach (Feature feature in input) { CoordinateSystemFactory csf = new CoordinateSystemFactory(); ICoordinateSystem cssource = csf.CreateFromWkt(((SharpMapSpatialReference)feature.getGeometry().SpatialReference).CoordinateSystem.WKT); ICoordinateSystem cstarget; if (translateScript != null) { //Console.WriteLine(Registry.instance().GetEngine("Python").run(TranslateScript).asString()); cstarget = csf.CreateFromWkt(Registry.instance().GetEngine("Python").run(TranslateScript).asString()); } else { cstarget = csf.CreateFromWkt(env.getInputSRS().WKT); } CoordinateTransformationFactory ctf = new CoordinateTransformationFactory(); ICoordinateTransformation ct = ctf.CreateFromCoordinateSystems(cssource, cstarget); //if (feature.getGeometry().GeometryType == GeometryType2.Point) //{ // Point p = (Point)feature.getGeometry(); //GeometryTransform.TransformPoint(feature, ct.MathTransform); Geometry geom = feature.getGeometry(); Geometry geomRst = GeometryTransform.TransformGeometry(geom, ct.MathTransform); feature.setGeometry(geomRst); //} } return input; }
// FeatureFilter overrides public FeatureList process(Feature input, FilterEnv env);
public override FeatureList process(Feature input, FilterEnv env) { FeatureList output = new FeatureList(); if (transform != null && !transform.Identity()) { foreach (GeoShape shape in input.getShapes()) { XformVisitor visitor = new XformVisitor(); visitor.trans = transform; shape.accept(visitor); } } output.Add(input); return output; #if TODO // resolve the xlate shortcut Matrix working_matrix = xform_matrix; // TODO: this can go into process(FeatureList) instead of running for every feature.. if (getTranslateScript() != null) { ScriptResult r = env.getScriptEngine().run(getTranslateScript(), input, env); if (r.isValid()) working_matrix = Matrix.translate(r.asVec3()); else env.getReport().error(r.asString()); } if (working_srs != null || (working_matrix != null && !working_matrix.IsIdentity)) { foreach (GeoShape shape in input.getShapes()) { if (working_matrix != null && !working_matrix.IsIdentity) { XformVisitor visitor; visitor.mat = working_matrix; shape.accept(visitor); } if (working_srs != null && !working_srs.equivalentTo(env.getInputSRS())) { working_srs.transformInPlace(shape); } } } output.Add(input); return output; #endif throw new NotImplementedException(); }
static GeoPoint clampToTerrain(GeoPoint input, FilterEnv env) { #if TODO if (env.getTerrainNode() != null) { return GeomUtil.clampToTerrain(input, env.getTerrainNode(), env.getTerrainSRS(), env.getTerrainReadCallback()); } else { return input; } //if ( env.getTerrainNode() ) //{ // osg.ref_ptr<osgUtil.LineSegmentIntersector> isector; // if ( input.getSRS().isGeocentric() ) // { // osg.Vec3d vec = input; // vec.normalize(); // isector = new osgUtil.LineSegmentIntersector( // vec * input.getSRS().getEllipsoid().getSemiMajorAxis() * 1.2, // osg.Vec3d(0,0,0) ); // } // else // { // osg.Vec3d p = input; // osg.Vec3d vec(0,0,1); // isector = new osgUtil.LineSegmentIntersector( // p + vec * 1e7, // p - vec * 1e7 ); // } // RelaxedIntersectionVisitor iv; // iv.setIntersector( isector.get() ); // iv.setReadCallback( env.getTerrainReadCallback() ); // // env.getTerrainNode().accept( iv ); // if ( isector.containsIntersections() ) // { // return GeoPoint( // isector.getFirstIntersection().getWorldIntersectPoint(), // input.getSRS() ); // } //} //return input; #endif throw new NotImplementedException(); }
/** * Processes a single Feature. * * @param input * Individual Feature to process. * @param env * Runtime processing environment. * @return * A collection of Feature instances. The default implementation * of this method just returns the input in a list. */ public virtual FeatureList process(Feature input, FilterEnv env) { FeatureList output = new FeatureList(); output.Add(input); return output; }
public override FeatureList process(FeatureList input, FilterEnv env) { FeatureList output = new FeatureList(); //Boolean encontrado = false; SharpMap.Geometries.BoundingBox boundingBox = new SharpMap.Geometries.BoundingBox(longitudeMin,latitudeMin,longitudeMax,latitudeMax); foreach (Feature feature in input) { //if type of features is Point if (feature.row.Geometry is SharpMap.Geometries.Point) { SharpMap.Geometries.Point p = (SharpMap.Geometries.Point)feature.row.Geometry; if (boundingBox.Contains(p.GetBoundingBox())) { output.Add(feature); } } //if type of features is Polygon else if (feature.row.Geometry is SharpMap.Geometries.Polygon) { SharpMap.Geometries.Polygon polygon = (SharpMap.Geometries.Polygon)feature.row.Geometry; if (boundingBox.Contains(polygon.GetBoundingBox())) { output.Add(feature); } } //if type of features is MultiPolygon else if (feature.row.Geometry is SharpMap.Geometries.MultiPolygon) { SharpMap.Geometries.MultiPolygon mp = (SharpMap.Geometries.MultiPolygon)feature.row.Geometry; SharpMap.Geometries.BoundingBox bb = mp.GetBoundingBox(); if (boundingBox.Contains(bb)) { output.Add(feature); } } } if (successor != null) { if (successor is FeatureFilter) { FeatureFilter filter = (FeatureFilter)successor; FeatureList l = filter.process(output, env); } else if (successor is FragmentFilter) { FragmentFilter filter = (FragmentFilter)successor; FragmentList l = filter.process(output, env); } } return output; }
public override FeatureList process(FeatureList input, FilterEnv env) { FeatureList output = new FeatureList(); // HACER ALGO DEL ESTILO: if (transform == null) { //Create zone UTM 32N projection IProjectedCoordinateSystem utmProj = CreateUtmProjection(32); //Create geographic coordinate system (lets just reuse the CS from the projection) IGeographicCoordinateSystem geoCS = utmProj.GeographicCoordinateSystem; //Create transformation CoordinateTransformationFactory ctFac = new CoordinateTransformationFactory(); // TODO DANI Mirar de donde viene este source y target ICoordinateTransformation Coordinatetransform = null;// TODO = ctFac.CreateFromCoordinateSystems(source, target); //cs string wkt = "GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.0174532925199433]]"; //ICoordinateSystem cs = SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.Parse(wkt) as ICoordinateSystem; ICoordinateSystem cs = ProjNet.Converters.WellKnownText.CoordinateSystemWktReader.Parse(wkt) as ICoordinateSystem; //wgs84 GeographicCoordinateSystem wgs84 = GeographicCoordinateSystem.WGS84; //gcs CoordinateSystemFactory cFac = new ProjNet.CoordinateSystems.CoordinateSystemFactory(); //CoordinateSystemFactory cFac = new SharpMap.CoordinateSystems.CoordinateSystemFactory(); //Create Bessel 1840 geographic coordinate system IEllipsoid ellipsoid = cFac.CreateFlattenedSphere("Bessel 1840", 6377397.155, 299.15281, LinearUnit.Metre); IHorizontalDatum datum = cFac.CreateHorizontalDatum("Bessel 1840", DatumType.HD_Geocentric, ellipsoid, null); IGeographicCoordinateSystem gcs = cFac.CreateGeographicCoordinateSystem("Bessel 1840", AngularUnit.Degrees, datum, PrimeMeridian.Greenwich, new AxisInfo("Lon", AxisOrientationEnum.East), new AxisInfo("Lat", AxisOrientationEnum.North)); //coordsys //Collection<ProjectionParameter> parameters = new Collection<ProjectionParameter>(5); List<ProjectionParameter> parameters = new List<ProjectionParameter>(); parameters.Add(new ProjectionParameter("latitude_of_origin", 0)); parameters.Add(new ProjectionParameter("central_meridian", 110)); parameters.Add(new ProjectionParameter("scale_factor", 0.997)); parameters.Add(new ProjectionParameter("false_easting", 3900000)); parameters.Add(new ProjectionParameter("false_northing", 900000)); IProjection projection = cFac.CreateProjection("Mercator_1SP", "Mercator_1SP", parameters); IProjectedCoordinateSystem coordsys = cFac.CreateProjectedCoordinateSystem("Makassar / NEIEZ", gcs, projection, LinearUnit.Metre, new AxisInfo("East", AxisOrientationEnum.East), new AxisInfo("North", AxisOrientationEnum.North)); Coordinatetransform = ctFac.CreateFromCoordinateSystems(gcs, coordsys);//gcsWGS84 -> gcenCsWGS84 //Apply transformation transform = Coordinatetransform.MathTransform; } SharpMap.Geometries.Point p = new SharpMap.Geometries.Point(30.0, 20.0); p = GeometryTransform.TransformPoint(p,transform); /*IMPORTANTE foreach (Feature feature in input) { feature.row.Geometry = GeometryTransform.TransformGeometry(feature.row.Geometry, transform); //feature.row.Geometry = GeometryTransform.TransformMultiPolygon(feature.row.Geometry, transform); } IMPORTANTE*/ foreach (Feature f in input) { output.Add(f);//output = input } // Cosas a cambiar: // Primero, la construccion del transform está siguiendo el ejemplo, pero hay que tener en cuenta los datos del xml y construirlo en consecuencia // Segundo, el filtro debe retornar una NUEVA lista, y no modificar la inicial. Ahora modifica los valores de la lista inicial // IMPORTANTE RETORNAR NUEVA LISTA OUTPUT <----------- FALTA POR HACER #if TODO // first time through, establish a working SRS for output data. if (working_srs == null) { // first try to use the terrain SRS if so directed: SpatialReference new_out_srs = getUseTerrainSRS() ? env.getTerrainSRS() : null; if (new_out_srs == null) { // failing that, see if we have an SRS in a resource: if (getSRS() == null && getSRSScript() != null) { ScriptResult r = env.getScriptEngine().run(getSRSScript(), env); if (r.isValid()) setSRS(env.getSession().getResources().getSRS(r.ToString())); else env.getReport().error(r.ToString()); } new_out_srs = srs; } // set the "working" SRS that will be used for all features passing though this filter: working_srs = new_out_srs != null ? new_out_srs : env.getInputSRS(); // LOCALIZE points around a local origin (the working extent's centroid) if (working_srs != null && getLocalize()) //&& env.getExtent().getArea() > 0.0 ) { if (env.getCellExtent().getSRS().isGeographic() && env.getCellExtent().getWidth() > 179.0) { //NOP - no localization for big geog extent ... needs more thought perhaps } else { GeoPoint centroid0 = new_out_srs != null ? new_out_srs.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; Matrixd localizer; // For geocentric datasets, we need a special localizer matrix: if (working_srs.isGeocentric()) { localizer = working_srs.getEllipsoid().createGeocentricInvRefFrame(centroid); localizer.invert(localizer); } // For projected datasets, just a simple translation: else { localizer = osg.Matrixd.translate(-centroid); } working_srs = working_srs.cloneWithNewReferenceFrame(localizer); } } } // we have to assign the output SRS on each pass if (working_srs != null) { env.setOutputSRS(working_srs); } return base.process(input, env); #endif //throw new NotImplementedException(); if (successor != null) { if (successor is FeatureFilter) { FeatureFilter filter = (FeatureFilter)successor; FeatureList l = filter.process(output, env); } else if (successor is FragmentFilter) { FragmentFilter filter = (FragmentFilter)successor; FragmentList l = filter.process(output, env); } } return output; }