As part of Map Suite's new annual release cycle, we will be incrementally unveiling new features and enhancements that are targeted for the next major version via our Daily Development Builds. This will give our users a chance to get the newest features before the May 2013 release of Map Suite 7.0, and also allow us to collect feedback on these new features as we work to polish and perfect them. Your feedback is an integral part of Map Suite's evolution, so be sure to let us know your thoughts about the new beta features.
To access the Daily Development Builds, all you'll need to do is login to the ThinkGeo Customer Portal and then do one of the following:
- To download an evaluation daily build, click the "Evaluation Daily Builds" link at the top of the screen, then select the product you want to download.
- To download a full daily build for a product you have purchased, click the "My Product Downloads" link at the top of the screen, then click on the "Daily Development Builds" tab and select the product you want to download. (You'll need a current Software Assurance Plan.)
We will be adding new posts to this topic as new beta features become available, so we suggest that you subscribe to the topic by checking the checkbox at the top of this post. This will allow you to receive instant email notification when new updates are added.
Table of Contents
Available in Map Suite 6.0.36.0 and Higher
Enhanced Geometry Functions
We are pleased to announce that we have enhanced Map Suite's geometric functions in an effort to increase their speed, accuracy and reliability. What we have introduced is an unmanaged geometry piece to our solution which can, in many cases, dramatically increase the speed of geometry operations. It is supported by hundreds of test cases, so we are confident that we have covered most of the areas of functionality. However, some of the new operations are not as forgiving on bad geometries as the managed library that you are used to using. To mitigate this, we have also provided an improved IsValid method and a MakeValid function as well to help fix bad shapes.
From a compatibility standpoint, the daily builds will default to using the new unmanaged assembly starting now, so you will need the new dependencies. Due to the unmanaged nature of the new library, we are including a merge module, DLLs and XCopy deployment instructions to assist you in getting the dependencies in the right places. Look for the file named UnmanagedAssembliesDeploymentGuide.txt in your downloaded daily build package for details. We understand that there may be some scenarios where you are not able to update the Windows folder, and in that case we have included a BaseShape.GeometryLibrary property which allows you to switch between the original managed and the new unmanaged version.
Update July 12, 2012: Please note that there are some additional dependencies that are not XCopy compatible; however, they are very common. The first is the .NET 4 Client Profile which can be installed via Windows Update, and the second is the Microsoft VC 10.0 Runtime which can be installed via the merge modules listed below.
On a machine with Visual Studio 2010 installed:
C:\Program Files (x86)\Common Files\Merge Modules\ Microsoft_VC100_CRT_x86.msm
C:\Program Files (x86)\Common Files\Merge Modules\ Microsoft_VC100_CRT_x64.msm
In a scenario where you cannot install these dependencies, remember that you always have the option to use the original managed geometry library instead.
While this feature is in the daily builds we will default the property to unmanaged in an attempt to get the widest audience for testing. In the released version, for compatibility, we will default this to unmanaged to help out our users who want a drag-and-drop upgrade to our latest released version.
From a pure speed perspective, we are not yet able to realize the full potential of the new library. The reason is that BaseShape and its sub classes add quite a bit of overhead to the spatial. In conjunction with this enhancement, we are also in the process of replacing BaseShape with an enhanced Feature class and set of sub classes. Further details on the new Feature classes can be found below, so please check that out as well.
Our goal is that in the near future we want to dramatically increase the speed of geometry operations, interactive overlays, and at the same time make our API easier to understand and leverage.
As always, if you have any questions or feedback please feel free to post to the forums and let us know.
Preview: Upcoming Features & Shapes Overhaul in Map Suite 7.0
The Feature structure is probably one of the least understood and hardest to use object we have in Map Suite. Its original design was to be an efficient and low-memory transport for spatial data, specifically well-known binary, from the original source through the drawing subsystem. We chose this as a result of what we learned from developing Map Suite 2.0, which had memory issues linked to the fact that each geometry was a class, and every point within it caused high memory consumption and put a lot of pressure on the garbage collector.
Our idea for Features was to create something small and sleek with no frills that would primarily be used during the main drawing process, since most of the time user code never touches the Features. To handle the cases where you wanted to examine the geometry or do geometric functions, we would create an entire family of shape derived classes. The point of these was to make the exploration and processing very elegant and user friendly, and have a rich inheritance story for extensibility.
However, we found over time that our approach to Features had four major drawbacks.
- Structures are not the most friendly objects to deal with. As they are immutable and in most cases indistinguishable from classes, many developers assume they pass by reference and are confused when they cannot change them.
- The original sleek and small structure started to grow and grow some more, until the memory savings were not as noticeable. Structures are recommended to be small as they need to be copied over and over again on the stack; once the object gets to a certain size then things start to slow down and we were starting to see this happening in Map Suite.
- By creating the Feature and its derived Shapes, we created two tiers of objects that users essentially saw as the same thing. This required us to create many overloads to take each type, and that confused users as to which type to use in what situations.
- Using Shapes to do geometric functions was slow because in the end we need to create Shapes again. This significantly slows down operations where you need to go from one operation to the next and pipeline the results between them.
To correct the problems described above, we have a multi-step plan for Map Suite 7.0 to enhance the API, making it more intuitive and easier to use overall.
The first phase of the plan involves converting the Feature structure to a class. In our own testing, this change has only impacted one line of source code in our entire library, so we feel that the change is safe from a compatibility standpoint. In addition, we will add the core geometric functions to the Feature so you will be able to union, buffer, get a difference, etc. and it will return a Feature. This gives us a high-speed way to accomplish the geometric functions. In total, the changes in phase one will make many of our APIs -- especially the interactive overlays -- much easier to enhance and pave the way for the next series of changes.
The second phase will be to inherit from the Feature to create a series of Features that mimic the Shapes we have now. For example, we will have a PolygonFeature, a MultiPolygonFeature, a LineFeature and so on, all of which will provide an easy-to-use API to explore and edit each Feature. It will also house the geometric functions.
After both phases have been implemented, we will mark all of the Shapes and API overloads that use Shapes obsolete. This will help guide you to the API that needs to be changed to conform to the new standards. We will leave them obsolete for more than one year and through the next major version of Map Suite, in order to provide you with a generous timeline to make the changes. With Map Suite 8.0 in 2014 we will finally remove the Shapes and Shape-related overloads and be left with one set of classes and an improved API.
In conjunction with this, we will be enhancing our InteractiveOverlays to use Features primarily to gain the new speed advantages. At this point we are not sure if we will be able to enhance the current classes or if we will need to create new classes. Our intuition currently leads us to think that we will enhance the existing classes as much as we can, but we may need to create new classes to fully leverage the new Feature class. The great news is that this should make things faster than ever and put us in a great position for the future.
As always we appreciate your feedback and will incorporate what we hear from you in our final design decisions. At this point the conversion of the Feature structure to a class has many benefits and nearly zero drawbacks, so we are confident about moving forward. As we gather feedback and start the next phase, we will share with you our progress and ideas. This is a major API change and we want to accomplish it as smoothly and with as little disruption as possible. In some ways we have thought about not pursuing this change, but then we considered all of the new developers to Map Suite and how much nicer it will be for them to have a uniform and sleek API and that won out in the end.
Update: June 26, 2012
Coming Soon: Map Suite .NET 4.0 Framework Upgrade
In our ongoing upgrade cycle through the Microsoft .NET Framework versions, we are happy to announce that we will soon be upgrading all of the products in our developer branch to the .NET 4.0 Framework. Our policy is to stay one framework version behind what is currently published by Microsoft, and with our Map Suite 6.0 release we stayed true to that ideal. We believe that the 4.5 Framework will be released shortly, before Windows 8, and we want to get ahead of the curve and upgrade Map Suite to the 4.0 Framework.
We feel that this is a necessary step because the 4.0 Framework has a number of great features that we can leverage, such as MEF, Parallel For and IIS enhancements. As we plan for our 7.0 release of Map Suite, we want to make sure that we include all of these new technologies to make a large leap forward with our products. In conjunction with our earlier announcement regarding geometry and features, we intend to deliver a significant increase in the speed of our products and provide even more extensibility using the new 4.0 Framework.
Our plan is that over the following days we will start to upgrade the various project solutions to target the new framework version. Following this, over the next few months we will begin to enhance each Map Suite product to leverage the new framework features. We will make more announcements as we target key pieces of functionality and will strive to be as communicative as possible about the enhancements and speedups. We welcome your feedback as always and look forward to delivering to you the best possible product, now and in the future.
Update: July 12, 2012 - Available in Map Suite 6.0.59.0 and Higher
WPF Editing Speed Enhancements
Based on user feedback, we have been focusing on improving the speed and memory usage of our TrackInteractiveOverlay and our EditInteractiveOverlay. To those ends we have made some great performance enhancements that are now available as of today's daily build of Map Suite WPF Desktop Edition.
In the past, when editing a large number of shapes (or even just a few complex shapes), the vertex dragging, vertex adding, rotating, and resizing of the shapes became very slow and was prone to using large amounts of memory. The main reason for this was that we draw all of the shapes for every change, which is actually not necessary. In our new approach, we focus on the vertex being adjusted or the shape being resized and just draw that. This greatly increases the speed in almost every scenario and allows us to confidently edit shapes of near-unlimited complexity quickly and with efficient use of memory.
One change you will notice, however, is that as you drag a vertex of a polygon or a line, the existing line will still show as you drag the vertex to its new location. The new vertex and its lines will display slightly differently as they are in progress. Although this is a change from what you may be used to, we think that it has some advantages — most importantly, you will now be able to see the original location of the vertex when you are moving it to a new location. We believe that the aesthetic changes are outweighed by the significant performance gains and other advantages.
Below is a short video demonstrating the speed and drawing difference:
In the near future we will be making additional investments into the editing system to make it more polished, decrease memory usage and gain additional speed. In addition, we will be investigating a new editing system similar to those found in popular graphic art packages as an alternative to the traditional GIS editing system. More on that to come over the new few weeks.
Update: July 18, 2012 - Available in Map Suite 6.0.65.0 and Higher
Enhanced Feature Validation & Correction
Startng with today's Daily Development Build of all of our Map Suite products (version 6.0.65.00, we have introduced some new ways to validate and possibly repair features. The new APIs link to the new unmanaged geometry library as well as the existing managed one to allow you to check if a feature is valid, and if it isn't, find out why it is not valid. By calling the IsValid we will return if the geometry is valid or not, and you can subsequently call the GetInvalidReason for a textual description as to why the feature is invalid.
In the case where you are using the new unmanaged geometry library, there is an option to fix invalid geometry by calling the MakeValid method. It is important to note that the existing managed geometry library does not support this,, so we added a property called CanMakeValid which will let you know if the MakeValid method is supported. I strongly suggest that you always call the CanMakeValid method before calling MakeValid to ensure that the latter is supported, otherwise it will throw an exception.
It is also important to note that the description returned by GetInvalidReason for why a feature is invalid is passed unmodified from the underlying geometry libraries, so the wording of these descriptions may be different. They are intended to be human readable, and as a result we do not recommend using them as error codes or linking the description text to the programmatic handling of the errors.
Here are the new feature validation APIs introduced in build 6.0.65.0:
public class Feature {
public Boolean CanMakeValid { get; }
public String GetInvalidReason();
public Boolean IsValid();
public Feature MakeValid();
}
Update: July 23, 2012 - Available in Map Suite 6.0.71.0 and Higher
Raster Reprojection Support
We are happy to announce that as of Daily Development Build 6.0.71.0 of Map Suite, we now support raster projection. This has been a highly requested feature and we have been working hard to bring it to you, our customers. One thing to note is that this does leverage unmanaged code and at this point there is no purely managed version. With this new feature, we support the same projections as our existing vector projection system. We expose the feature via any layer that inherits from RasterLayer, such as EcwRasterLayer, MrSidRasterLayer, etc.
To set up the projection for a RasterLayer, you need to set the Projection property on the RasterLayer.RasterSource.Projection similarly to how you set up projection on a vector layer. The Projection property takes a projection object, which is the same class as the one used by a vector layer's Projection property. As such, we have enhanced the Projection class with some new methods such as ConvertRasterToExternalProjection and CanConvertRasterToExternalProjection, which together add support for raster projection. We have also implemented raster projection support in our default Proj4Projection class which we encourage you to use; however, with the new API, you can integrate your own custom raster projections as well.
To accompany the initial release of this feature, we have produced a sample application that shows how the new raster projection system works. You can download the sample or view the source online on our wiki at http://wiki.thinkgeo.com/wiki/Map_S...Projection. Further along in this news post, we have also listed for you the relevant new classes and the additional methods and properties on existing classes.
Below is a short video produced by Map Suite Chief Architect David Rehagen which offers a demonstration of how the raster projection sample app works:
Raster Projection Dependencies
- In the daily build package for Map Suite 6.0.71.0 and higher, you will find two new folders:
- MapSuiteGeoRasterProjectionX86
- MapSuiteGeoRasterProjectionX64
You will need to copy both of these folders into your %SYSTEMROOT%\System32 folder. If you are using a 64-bit edition of Windows, you also need to copy both folders into your %SYSTEMROOT%\SysWOW64 folder.
- You will want to download the new raster reprojection merge modules.
- And of course, make sure you reference the DLLs from version 6.0.71.0 Development Daily Build of Map Suite or higher. You can get them from our Customer Portal.
For a high-level guide about Map Suite dependencies and deployment, see our wiki — there's a guide for each product. Here, for example, is the Map Suite Desktop Edition deployment guide.
API Additions for Raster Projection
public class ManagedProj4Projection : Projection {
protected override RasterProjectionResult ConvertRasterToExternalProjectionCore(GeoImage image, RectangleShape imageExtent);
}
public class Proj4Projection : Projection, IDisposable {
protected override RasterProjectionResult ConvertRasterToExternalProjectionCore(GeoImage image, RectangleShape imageExtent);
}
public abstract class Projection {
public Boolean CanConvertRasterToExternalProjection { get; protected set; }
public RasterProjectionResult ConvertRasterToExternalProjection(GeoImage image, RectangleShape imageExtent);
protected virtual RasterProjectionResult ConvertRasterToExternalProjectionCore(GeoImage image, RectangleShape imageExtent);
}
public class RasterProjectionResult {
public RasterProjectionResult();
public RasterProjectionResult(GeoImage image, RectangleShape imageExtent);
public GeoImage Image { get; set; }
public RectangleShape ImageExtent { get; set; }
}
public abstract class RasterSource {
public Projection Projection { get; set; }
}
public class UnmanagedProj4Projection : Projection, IDisposable {
protected override RasterProjectionResult ConvertRasterToExternalProjectionCore(GeoImage image, RectangleShape imageExtent);
}
Update: August 30, 2012 - Available in Map Suite 6.0.109.0 and Higher
.NET 4.0 Framework Upgrade Complete; Improved Daily Build Packages
We have completed the upgrade of all of our Map Suite products and their samples to the .NET 4.0 framework! As such, all new daily development builds going forward will require the 4.0 framework to be installed on your development machine. In addition, we have streamlined a number of other things, includng how you work with daily builds and how Map Suite works with unmanaged assemblies.
While upgrading to .NET framework 4.0, we found that we also needed to update the way we call unmanaged assemblies. During this research, we discovered that we could remove some of the dependence DLLs that we had used in the past as middlemen. This has caused the number of dependency files to drop considerably, which means less files to distribute with your application.
In doing this, and examining the daily build DLL packages, we found them to be difficult to use and especially difficult to keep on top of unmanaged DLL upgrades. To mitigate this, we reworked our daily development DLL packs so that they are much easier to use. In each DLL pack we now have just two folders called "Managed Assemblies" and "Managed Assemblies – Strong Named" where you will find all of the managed DLLs. Additionally, to make the unmanaged DLLs easier to work with, we have bundled them into a small installer called "Setup Unmanaged Dependencies". Simply run this installer and you will be up to date with the latest unmanaged assemblies for both x86 and x64.
We think you'll agree that this really takes the complexity out of upgrading to a newer version of Map Suite! Of course when you are ready to build or update your installer, you can find the latest merge modules and loose DLLs in zip format on the appropriate deployment guide for your specific product. You'll find the deployment guides on our wiki — for example, here is the deployment guide for Map Suite Desktop Edition.
Below is a short video produced by Map Suite Chief Architect David Rehagen which will walk you through an exploration of one of the latest daily build packages and show you the improvements.
Download the above video (WMV) from ThinkGeo
Update: September 4, 2012 - Available in Map Suite 6.0.113.0 and Higher
Map Suite Routing: Drive Time Polygon Enhancements
Today's daily development builds include two new enhancements to the "drive time" feature of our Routing extension for Map Suite. The first enhancement improves the visual appeal and accuracy of the resulting drive time polygon. The second enhancement allows you to incorporate the individual road speed in the calculation of the drive time polygon, instead of simply using an average speed.
We made a number of changes to how we create the drive time polygon from the reachable streets. Previously, there were some scenarios where the drive time polygon was jagged and covered areas that may not be accessible around the fringes. With the latest series of enhancements, we have removed the spikes and more accurately represented the areas reachable. Of course, drive time polygons are always an estimate based on average or weighted speeds and as you move further from the center they are inherently more unreliable.
We have also introduced a new API that allows you to calculate the drive time polygon based on individually weighted street speeds and not just an average speed. This allows much more accurate drive time polygons if you have the speed data for your roads. There are some caveats, the most important being that the weighting used when creating the routing file needs to be the road length divided by road speed. This makes those roads with high speeds seem shorter to the routing engine and thus more preferable.
Here is a visual comparison of two drive time polygons, the first created with a previous version of Map Suite Routing, and the second created with the latest daily build:
|
|
| Before |
After |
Update: September 4, 2012 - Available in Map Suite 6.0.113.0 and Higher
FileGeodatabase Support Comes to Map Suite
We are happy to announce that we now support ESRI's FileGeodatabase format. Leveraging the latest stable FileGeodatabase API released by ESRI, we have created a new FeatureSource and FeatureLayer for easy integration into your Map Suite applications. Our initial impressions with the format and new API is that it is very fast and easy to work with. We have included a video along with a Code Community sample you can download from our wiki that can help you through integrating your first dataset. We welcome your feedback; please let us know if there are additional features related to the format that you would like to see us implement.
Download the above video (WMV) from ThinkGeo
Update: September 4, 2012 - Available in Map Suite 6.0.113.0 and Higher
Map Suite Topology Validator
We are pleased to announce a new set of static Map Suite APIs relating to topology validation, along with an application to visualize and test topology rules. Topology validation is a critical function of a GIS application and we now have a great implementation of this feature. We have worked hard to ensure that we have included the most important cases along with an easy-to-use API. Below are a list of all of the cases we cover.
- Lines End Point Must Be Covered By Points
- Lines Must Be Covered By Boundary Of Polygons
- Lines Must Be Covered By Feature Class Of Lines
- Lines Must Be Larger Than Cluster Tolerance
- Lines Must Be Single Part
- Lines Must Not Have Dangles
- Lines Must Not Have Pseudonodes
- Lines Must Not Intersect Or Touch Interior
- Lines Must Not Intersect
- Lines Must Not Overlap With Lines
- Lines Must Not Overlap
- Lines Must Not Self Intersect
- Lines Must Not Self Overlap
- Points Must Be Covered By Boundary Of Polygons
- Points Must Be Covered By EndPoint Of Lines
- Points Must Be Covered By Lines
- Points Must Be Properly Inside Polygons
- Polygons Boundary Must Be Covered By Boundary Of Polygons
- Polygons Boundary Must Be Covered By Lines
- Polygons Must Be Covered By Feature Class Of Polygons
- Polygons Must Be Covered By Polygons
- Polygons Must Be Larger Than Cluster Tolerance
- Polygons Must Contain Point
- Polygons Must Cover Each Other
- Polygons Must Not Have Gaps
- Polygons Must Not Overlap With Polygons
- Polygons Must Not Overlap
- Validate Shapes
The Topology Validator sample application makes it simple to visualize and test topology rules. You simply select the case you want to test, use our drawing tools to create the shapes necessary, and then hit the play button to run the test. The error cases are highlighted on the screen and saved to the test, and their Well-Known Text (WKT) is copied to your clipboard. At any time, you can view or edit the WKT which makes up the case. We save our test cases as XML files that contain not only the test case features but also the errors. This makes it a snap for you to share your cases with us or other colleagues.
Download the above video (WMV) from ThinkGeo
Update: November 28, 2012 - Available in Map Suite 6.0.190.0 and Higher
Improved Oracle Support
Beginning with version 6.0.190.0 of the Daily Development Builds, the OracleFeatureSource and OracleFeatureLayer are integrated into MapSuiteCore.dll. We now take advantage of Oracle Data Access Component (Oracle.DataAccess.dll particularly) from this version and the latest Oracle Client (11.2.0) is required. If the Oracle Client's version is not correct, an exception of "The Oracle Client is not up to date, please install 11.2.0 or later" will be thrown.
Because some new dependencies are required, you will also need to install the MapSuiteOracleDependencies6.0.200.0.msi package. This file can be downloaded from the Dependencies Guide that is specific to the edition of Map Suite that you're using; these guides are located on our wiki. For example, here is the Dependencies Guide for Map Suite Desktop Edition. If for some reason the required dependencies are not found on a machine, an "Oracle dependencies cannot be found" exception will be thrown.
Performance is dramatically improved in this new version, offering speeds up to 6-10 times faster for small data, and you can now read huge data sets which took forever in prior versions. In testing, it took 121 seconds to GetAllFeatures() from a table containing 2,400,000 line records, and less than 1 second to return 797 records using GetFeaturesInsideBoundingBox() from the same table.
This version supports all of the Oracle Types, including Curve, Circle, GeoCollection, etc. We currently support the 3D geometries by ignoring the Z values and simply displaying the features in a flat manner. The changes are reflected in all of our Map Suite products: WPF, Web, MVC, Desktop, Services and Silverlight Editions.
There are essentially no API changes except for the following:
- We added BuildIndex() for building the Oracle index.
- We added OracleConnectionMode to specify whether to keep the connection open or auto-close it after every operation (auto-close is the default).
Here are the corresponding APIs for the above items:
public enum OracleConnectionMode {
Default,
AutoClose,
KeepOpen
}
public class OracleFeatureLayer : FeatureLayer {
public void BuildIndex();
public void BuildIndex(BuildIndexMode mode);
public OracleConnectionMode connectionMode{ get; set; }
}
public class OracleFeatureSource : FeatureSource {
public void BuildIndex();
public void BuildIndex(BuildIndexMode mode);
public OracleConnectionMode connectionMode{ get; set; }
}
Update: November 28, 2012 - Available in Map Suite 6.0.190.0 and Higher
An Introduction to WMTSOverlays
Beginning with version 6.0.190.0 of the Daily Development Builds, WMTS layers and overlays are now supported in the following products: Map Suite Services, Desktop, Web, and WPF Desktop Edition. Their function is to consume data from a WMTS server and display it on the map. WMTS is similar to the WMS standard except that in WMTS the data is stored on the server as tiles that can be requested very quickly with little server overhead. This means that WMTS servers are typically faster than WMS servers, which need to render on-the-fly based on the requesting extent. WMTS is similar to the method employed by Google Maps or Bing Maps in the storage and retrieval of their raster data.
The code you'll use in Map Suite to display a WMTS layer is pretty straightforward and very similar to displaying WMS layers. Behind the scenes, it requests tiles from the server asynchronously and stitches them together to form the map regardless of whether your tile size syncs up with the server's tile size.
To see how easy it is to use WMTS layers and overlays, have a look at the sample applications that we've built specifically for the following Map Suite editions:
Here is the API for the new WmtsLayer:
[SerializableAttribute]
public class WmtsLayer : Layer {
//Constructors
public WmtsLayer(IEnumerable<Uri> serverUris, WebProxy webProxy);
public WmtsLayer(IEnumerable<Uri> serverUris, WebProxy webProxy, WmtsSeverEncodingType wmtsSeverEncodingType);
public WmtsLayer();
public WmtsLayer(IEnumerable<Uri> serverUris);
//Events
public event EventHandler<SendingWebRequestEventArgs> SendingWebRequest;
public event EventHandler<SentWebRequestEventArgs> SentWebRequest;
//Properties
public String ActiveLayerName { get; set; }
public String ActiveStyleName { get; set; }
public TimeSpan CapabilitesCacheTimeOut { get; set; }
public ICredentials Credentials { get; set; }
public Double LowerScale { get; set; }
public String OutputFormat { get; set; }
public Dictionary<String,String> Parameters { get; }
public Collection<Uri> ServerUris { get; }
public BitmapTileCache TileCache { get; set; }
public String TileMatrixSetName { get; set; }
public Int32 TimeoutInSeconds { get; set; }
public Double UpperScale { get; set; }
public WebProxy WebProxy { get; set; }
public WmtsSeverEncodingType WmtsSeverEncodingType { get; set; }
//Methods
public void ClearCache();
public Collection<String> GetLayerOutputFormats(String layerName);
public Collection<Uri> GetRequestUris(RectangleShape requestExtent, Int32 canvasWidth, Int32 canvasHeight);
protected virtual Collection<Uri> GetRequestUrisCore(RectangleShape requestExtent, Int32 canvasWidth, Int32 canvasHeight);
public String GetServerCapabilitiesXml();
public Collection<String> GetServerLayerNames();
public Collection<String> GetServerLayerStyles();
public Collection<String> GetServerTileMatrixSetNames();
protected virtual void OnSendingWebRequest(SendingWebRequestEventArgs e);
protected virtual void OnSentWebRequest(SentWebRequestEventArgs e);
protected WebResponse SendWebRequest(WebRequest webRequest);
protected virtual WebResponse SendWebRequestCore(WebRequest webRequest);
//Implemented Interfaces and Overridden Members
protected override void OpenCore();
[ObsoleteAttribute("This method is obsoleted. This API is only used internally and will be replaced by a new API in the near future. Please do not call this API.")]
protected override ThreadSafetyLevel GetThreadSafetyLevelCore();
protected override void CloseCore();
protected override void DrawCore(GeoCanvas canvas, Collection<SimpleCandidate> labelsInAllLayers);
protected override void DrawExceptionCore(GeoCanvas canvas, Exception e);
}
[SerializableAttribute]
public enum WmtsSeverEncodingType {
Kvp,
Restful
}
Update: November 28, 2012
New Dependencies Guides for Map Suite Available Now
We have recently added a new Dependencies Guide to each "Product Guides" section of the Map Suite Wiki, with a separate guide specially tailored to each product edition. In this guide you will find a convenient grid listing each of our features that requires a dependency, the dependency version and the location where you can acquire it. We split the grid into two sections, showing separate areas for the latest public release of Map Suite as well as the current Daily Development Build. This will tell you exactly what version of a third-party dependency we are using as well as its origin website.
For quick reference, here are links to each Dependencies Guide by product edition:
We hope this makes things more clear when packaging your application using Map Suite. Of course we still provide merge modules containing all of our dependencies broken out by feature for easy integration with your installer package.
Feel free to post your thoughts and/or suggestions on the above ideas here on this thread, or send them to us by email if you prefer.
Thanks for choosing Map Suite,
The ThinkGeo Team