mg-desktop: advanced features

Previously, I showed you how to get a basic mg-desktop application up and running.

For this post, I am going to introduce some of the more advanced features and functionality of mg-desktop

Viewer Properties


The mg-desktop viewer (MgMapViewer) exposes a whole bunch of properties that can control the behaviour and appearance of certain features in the map viewer.

Each property is explained below

• ConvertTiledGroupsToNonTiled - Tiled Layer Groups will be treated as regular map groups, allowing for such groups and layers to be shown in the viewer. This is a simple workaround for the viewer's current inability to display map tiles. 
• SelectionColor - Controls the color of selected features in the viewer
• ShowVertexCoordinatesWhenDigitizing - When you are digitizing, the vertex coordinates are shown at each node of the currently digitized geometry. For circles and points, no vertex coordinates are displayed because such shapes have no vertices. For example, digitizing a polygon would look like this:

• ZoomInFactor - The zoom scale multiplier to apply for zooming in
• ZoomOutFactor - The zoom scale multiplier to apply for zooming out

Digitizing and Measuring

Like the AJAX and Fusion viewers, the mg-desktop viewer has built-in geometry digitizing functionality.

   1:  public interface IMapViewer

   2:  {

   3:      //

   4:      // Summary:

   5:      //     Starts the digitization process for a circle

   6:      //

   7:      // Parameters:

   8:      //   callback:

   9:      //     The callback to be invoked when the digitization process completes

  10:      void DigitizeCircle(CircleDigitizationCallback callback);

  11:      //

  12:      // Summary:

  13:      //     Starts the digitization process for a line

  14:      //

  15:      // Parameters:

  16:      //   callback:

  17:      //     The callback to be invoked when the digitization process completes

  18:      void DigitizeLine(LineDigitizationCallback callback);

  19:      //

  20:      // Summary:

  21:      //     Starts the digitization process for a line string (polyline)

  22:      //

  23:      // Parameters:

  24:      //   callback:

  25:      //     The callback to be invoked when the digitization process completes

  26:      void DigitizeLineString(LineStringDigitizationCallback callback);

  27:      //

  28:      // Summary:

  29:      //     Starts the digitization process for a point

  30:      //

  31:      // Parameters:

  32:      //   callback:

  33:      //     The callback to be invoked when the digitization process completes

  34:      void DigitizePoint(PointDigitizationCallback callback);

  35:      //

  36:      // Summary:

  37:      //     Starts the digitization process for a polygon

  38:      //

  39:      // Parameters:

  40:      //   callback:

  41:      //     The callback to be invoked when the digitization process completes

  42:      void DigitizePolygon(PolygonDigitizationCallback callback);

  43:      //

  44:      // Summary:

  45:      //     Starts the digitization process for a rectangle

  46:      //

  47:      // Parameters:

  48:      //   callback:

  49:      //     The callback to be invoked when the digitization process completes

  50:      void DigitizeRectangle(RectangleDigitizationCallback callback);

  51:  }

The digitization API is very similar to the AJAX viewer. To digitize a circle for example, you would call the API like so:

   1:  mgMapViewer1.DigitizeCircle(OnCircleDigitized);

The OnCircleDigitized method must match the signature of the CircleDigitizationCallback delegate, which looks like this:

   1:  private void OnCircleDigitized(double x, double y, double radius)

   2:  {

   3:      //x, y is the circle center in the map's coordinates

   4:      //radius is the circle's radius

   5:  }

While digitizing, the digitization process can be aborted by pressing the ESC key. If digitization is aborted, the digitization callback will not be called by the viewer.

Tools like measuring can be built on this functional primitive of digitization. Here's an example using a line digitizer:

   1:  private void btnMeasure_Click(object sender, EventArgs e)

   2:  {

   3:      mgMapViewer1.DigitizeLine(OnLineDigitized);

   4:  }

   5:   

   6:  private void OnLineDigitized(double x1, double y1, double x2, double y2)

   7:  {

   8:      MgMapBase map = mgMapViewer1.GetMap();

   9:      //Create a coordiante system from the map's SRS

  10:      MgCoordinateSystemFactory csFactory = new MgCoordinateSystemFactory();

  11:      MgCoordinateSystem mapCs = csFactory.Create(map.GetMapSRS());

  12:   

  13:      //Invoke the appropriate measure method depending on the type

  14:      //of coordinate system

  15:      double dist = 0.0;

  16:      if (mapCs.GetType() == MgCoordinateSystemType.Geographic)

  17:          dist = mapCs.MeasureGreatCircleDistance(x1, y1, x2, y2);

  18:      else

  19:          dist = mapCs.MeasureEuclideanDistance(x1, y1, x2, y2);

  20:   

  21:      //Convert this distance to meters

  22:      dist = mapCs.ConvertCoordinateSystemUnitsToMeters(dist);

  23:   

  24:      MessageBox.Show("Distance is: " + dist + " meters");

  25:  }

Using the digitizing API combined with the existing MgGeometry and MgCoordinateSystem APIs, you can measure in ways other than simple point A - point B distance measuring.

Redlining


When you combine digitization with feature manipulation provided by the MapGuide API, you have the basis for redlining. Here's an example of creating point features from digitized points:

   1:  private MgdLayer _pointLayer;

   2:   

   3:  private void btnDrawPoint_Click(object sender, EventArgs e)

   4:  {

   5:      mgMapViewer1.DigitizePoint(OnPointDrawn);

   6:  }

   7:   

   8:  private void OnPointDrawn(double x, double y)

   9:  {

  10:      if (_pointLayer == null) //Our point layer doesn't exist

  11:          CreateRedlineLayer();

  12:      

  13:      //Now insert our point. This code should look familiar

  14:      //to you, setting up the MgPropertyCollection for insertion

  15:      MgPropertyCollection props = new MgPropertyCollection();

  16:      MgWktReaderWriter wktRw = new MgWktReaderWriter();

  17:      MgAgfReaderWriter agfRw = new MgAgfReaderWriter();

  18:   

  19:      MgGeometry geom = wktRw.Read("POINT (" + x + " " + y + ")");

  20:      MgByteReader agf = agfRw.Write(geom);

  21:   

  22:      MgGeometryProperty geomProp = new MgGeometryProperty("Geometry", agf);

  23:      props.Add(geomProp);

  24:   

  25:      //Here's where we differ from the official MapGuide API

  26:      //instead of a monolithic UpdateFeatures() that tries to 

  27:      //do everything, we have individual InsertFeatures/DeleteFeatures/UpdateFeatures

  28:      //methods. So here's the mg-desktop way

  29:   

  30:      MgFeatureReader result = _pointLayer.InsertFeatures(props);

  31:      result.Close();

  32:   

  33:      //Or if you have have access to the MgdLayer instance

  34:      /*

  35:      MgResourceIdentifier fsId = new MgResourceIdentifier(_pointLayer.GetFeatureSourceId());

  36:      MgServiceFactory factory = new MgServiceFactory();

  37:      MgdFeatureService featSvc = (MgdFeatureService)factory.CreateService(MgServiceType.FeatureService);

  38:      MgFeatureReader fr = featSvc.InsertFeatures(fsId, "Default:Redline", props);

  39:      fr.Close();

  40:       */

  41:      

  42:      //Now refresh to see your newly drawn point

  43:      mgMapViewer1.RefreshMap();

  44:  }

  45:   

  46:  private void CreateRedlineLayer()

  47:  {

  48:      MgMapBase map = mgMapViewer1.GetMap();

  49:      MgServiceFactory fact = new MgServiceFactory();

  50:      MgdFeatureService featSvc = (MgdFeatureService)fact.CreateService(MgServiceType.FeatureService);

  51:      MgResourceService resSvc = (MgResourceService)fact.CreateService(MgServiceType.ResourceService);

  52:   

  53:      //Note that mg-desktop does not have a concept of sessions like the

  54:      //official MapGuide API, but it *does* allow session-based resources 

  55:      //as a way of having temporary resources. Such resources will reside

  56:      //in a special directory for session resources (specified in Platform.ini)

  57:      //

  58:      //You can plug whatever string as the session id, but the resource identifier

  59:      //must satisfy the session id pattern:

  60:      //

  61:      // Session:<session id string>//Path/To/Your.ResourceType

  62:      //

  63:      //These files are removed with MgPlatform.Terminate(), which is called in this

  64:      //application as part of the exiting process.

  65:      string sessionId = Guid.NewGuid().ToString();

  66:      MgResourceIdentifier fsId = new MgResourceIdentifier("Session:" + sessionId + "//Redline.FeatureSource");

  67:      MgResourceIdentifier ldfId = new MgResourceIdentifier("Session:" + sessionId + "//Redline.LayerDefinition");

  68:   

  69:      //Create our point redline schema. It looks like this:

  70:      //

  71:      // Default

  72:      //    Redline

  73:      //        ID (int32, autogenerated)

  74:      //        Geometry (coordinate system same as map

  75:      string featureClass = "Default:Redline";

  76:      string geometry = "Geometry";

  77:   

  78:      MgFeatureSchema schema = new MgFeatureSchema("Default", "Redline schema");

  79:      MgClassDefinition cls = new MgClassDefinition();

  80:      cls.Name = "Redline";

  81:   

  82:      MgDataPropertyDefinition id = new MgDataPropertyDefinition("ID");

  83:      id.DataType = MgPropertyType.Int32;

  84:      id.SetAutoGeneration(true);

  85:   

  86:      MgGeometricPropertyDefinition geom = new MgGeometricPropertyDefinition(geometry);

  87:      geom.SpatialContextAssociation = "Default";

  88:      geom.GeometryTypes = MgFeatureGeometricType.Curve | MgFeatureGeometricType.Point | MgFeatureGeometricType.Solid | MgFeatureGeometricType.Surface;

  89:   

  90:      MgPropertyDefinitionCollection clsProps = cls.GetProperties();

  91:      clsProps.Add(id);

  92:      clsProps.Add(geom);

  93:   

  94:      MgPropertyDefinitionCollection idProps = cls.GetIdentityProperties();

  95:      idProps.Add(id);

  96:   

  97:      cls.DefaultGeometryPropertyName = geometry;

  98:      MgClassDefinitionCollection classes = schema.GetClasses();

  99:      classes.Add(cls);

 100:   

 101:      //Create the feature source with this schema. We use the map's

 102:      //coordinate system for the feature source to ensure features

 103:      //that we create, will line up with the map

 104:      MgCreateSdfParams create = new MgCreateSdfParams("Default", map.GetMapSRS(), schema);

 105:      featSvc.CreateFeatureSource(fsId, create);

 106:   

 107:      //Then create the layer definition. RedlineLayer.xml contains the template

 108:      string xml = string.Format(File.ReadAllText("RedlineLayer.xml"), fsId.ToString(), featureClass, geometry);

 109:      var bytes = Encoding.UTF8.GetBytes(xml);

 110:      MgByteSource source = new MgByteSource(bytes, bytes.Length);

 111:      resSvc.SetResource(ldfId, source.GetReader(), null);

 112:   

 113:      //Now create the runtime layer and add to map

 114:      _pointLayer = new MgdLayer(ldfId, resSvc);

 115:      _pointLayer.LegendLabel = "Redlining";

 116:      _pointLayer.Name = "Redline";

 117:      _pointLayer.Visible = true;

 118:      _pointLayer.Selectable = true;

 119:      _pointLayer.DisplayInLegend = true;

 120:   

 121:      var layers = map.GetLayers();

 122:      layers.Insert(0, _pointLayer);

 123:  }

An updated sample (building on the previous sample application) containing the above snippets is available for download here