More

Created custom tiles, added tile bounds to leaflet but it's still trying to load tiles outside of boundaries


I created custom tiles in TileMill with latitude/longitude boundaries of:

-89.8235,43.3377,-89.5952,43.4741

I added those tiles into the map and set the tile layer's bounds attribute, but Leaflet still is giving me a lot of "Not Found" errors in the console.

Here's my code for adding the tiles:

{ "parks boundaries": L.tileLayer('data/custom-tiles/boundaries/{z}/{x}/{y}.png">

I think you are asking the wrong question…

Leaflet does the right thing: the tiles you see in your errors belong to your boundaries.

To be convinced of it, please have a look at this JSFiddle where your boundaries are shown as a rectangle.

You see that Leaflet only loads the tiles needed and that 14/4105/5993.png">ShareImprove this answeranswered Dec 15 '14 at 12:59YaFredYaFred9396 silver badges8 bronze badges

Django-leaflet-cadasta 0.21.0

django-leaflet allows you to use Leaflet in your Django projects.

It embeds Leaflet version 1.0.3.

Main purposes of having a python package for the Leaflet Javascript library :

  • Install and enjoy
  • Do not embed Leaflet assets in every Django project
  • Enjoy geometry edition with Leaflet form widget
  • Control apparence and settings of maps from Django settings (e.g. at deployment)
  • Reuse Leaflet map initialization code (e.g. local projections)

1 Answer 1

Leaflet's L.Map class has an option to stop the copying of the map's overlays:

With this option enabled, the map tracks when you pan to another "copy" of the world and seamlessly jumps to the original one so that all overlays like markers and vector layers are still visible.

The proper way of making sure a user doesn't pan out a certain area is using L.Map 's maxBounds option:

When this option is set, the map restricts the view to the given geographical bounds, bouncing the user back when he tries to pan outside the view.

You could indeed top that off with setting the noWrap option on your L.TileLayer but all that in fact does is stop the tiles from repeating which is imo not the solution to your actual problem:

If set to true, the tiles just won't load outside the world width (-180 to 180 longitude) instead of repeating.


MapGuide tidbits: Improving bundled PHP performance

NOTE: This tip only applies to PHP that is bundled with MapGuide Open Source 2.6 and newer.

MapGuide Open Source 2.6 and newer bundles the 5.5.x series of PHP, which includes a new opcode caching feature. Opcode caching can reduce execution times by upwards of 50% (as is the case with our mapguide-rest functional test suite which usually took around 6 minutes to run, but now runs in just over 3 minutes with opcode caching enabled)

In the interest of playing it safe, we didn't activate this feature in the default php.ini that's bundled with MapGuide. So if you want to activate this feature, you'll have to edit php.ini and add the following lines:


Save the file (and restart the web server to re-jig PHP if required) and enjoy your faster PHP scripts!

UPDATE (18 Nov): Upon further testing, I've been finding that PHP opcache is horribly unstable on Windows (see this and this). So enable this feature at your own peril!


Layer support in MapML? #10

I'm not entirely clear about the split between the HTML <map> Element proposal and MapML, so I thought I'd raise an issue.

My understanding is that MapML is intended to be a standalone format to encode a map. That map could be rendered by some user agent. Now, the <map> element proposal describes a solution to embed maps in HTML, essentially representing maps as a stack of layers. In this model, MapML would typically be the format used to describe a given layer.

What bugs me is that the layering logic seems to be missing from MapML. In other words, MapML seems to be a standalone format to encode a map layer, and an HTML page seems required to render an interactive map with layers that can be switched on and off. Why aren't layers an integral part of MapML? (or are they already?)

The text was updated successfully, but these errors were encountered:

We are unable to convert the task to an issue at this time. Please try again.

The issue was successfully created but we are unable to update the comment at this time.

Prushforth commented Feb 16, 2018

Yes this is a good point, and something to consider.

In a MapML document, there is really no prior constraint on what content you can put, so you could/ can put tiles that overlap into the same document, and the composite result is the map. This is the case, for example in this service. That service is a bit hard to look at the source document unless you request it as Accept: text/mapml and edit the response as xml. If you do that you'll see that there are two <tile> elements for each row/col unique combination in the extent. So that is one way that a MapML document supports layers.

Another way which we developed during Testbed 13 was to include <template> elements for image or tile sources. This service is a bit easier to view the source in a browser (will eventually get deployed to the first url, right now its still in development).

So that's the second way (really just another way of accomplishing the first scenario) where there are multiple overlapping content sources for the same area.

I believe we should be able to combine tiles, images and vectors in a similar way ( in a single document) but haven't done too much experimentation in that direction yet.

Finally, something that we haven't experimented with but which I believe made it into the engineering report was actually allowing the <layer> element in a MapML document, such that it would dereference the @ src attribute. I'm not sure yet if there are any 'gotchas' in that scenario, but it might be useful for, for example, animating layers using CSS. We built a little application that could have used such animation had it existed, here.

At the end of the day, it's true that any MapML client must have the concept of a map already, whether it be a GIS program or a browser with the <map> client element. The client can then use MapML documents as layers in the map.

Prushforth commented Feb 26, 2018

To follow up a bit on this, the conceptual model of MapML is based on the concept of a document. The notion is that the document represents a map. The content layout for a map document follows the painter's model. If the client application has the idea of a "map", then it should be natural to manipulate layers in the user interface.

In a GIS user interface, the "map" is the basis of the user interface, and map "furniture" is supplied to aid in manipulating the layers. Although the primary client of MapML is designed to be the Web browser, there's no reason that I can see that MapML shouldn't be usable by GIS programs as well.

MapML document could also be the target of the URL bar in a browser, in a similar way that an SVG document can. In such a case, the map document is the browsing context. At that point, what is the difference between the browser and a GIS program? The program needs to provide the map infrastructure. Maybe for a browser that would be a synthesized HTML document with a <map> element with a <layer> element referring to the MapML document, similar to how the browser treats a URL for an image. But maybe one day we could have a model in which such a MapML document could load script? I think that has a lot of potential.

The DOM model doesn't seem to prescribe a user interface, just an object-oriented API. As far as I know, in HTML there doesn't seem to exist a way to specify scroll bars, for example, yet scrolling is an inherent user interface paradigm that is essential to representing a standard HTML document. Similarly in MapML, the idea of panning and zooming is almost inherent / driven by content.

Finally, there's the idea of a map/layer API. I think a minimalist API is essential, and should be based on the DOM / events. Leaflet and OpenLayers APIs are instructive, but we need to adapt to what is a sustainable basis for the browsers to provide. I also think the map needs to supply a drawing context in which what gets drawn gets geocoded, and can be serialized by script in a straightforward way, especially as JSON.

Tidoust commented Mar 5, 2018

Some follow-up comments to clarify how I approach this (and keep in mind I don't claim any expertise there):

To follow up a bit on this, the conceptual model of MapML is based on the concept of a document. The notion is that the document represents a map. The content layout for a map document follows the painter's model. If the client application has the idea of a "map", then it should be natural to manipulate layers in the user interface.

It should be natural to manipulate layers in the user interface, provided there is a way to identify layers. A MapML document, which represents a map, does not seem to define a way to identify layers that compose the map. The painter's model merely states that things get drawn in order. It does not help with grouping things together into a layer.

Let's imagine a traffic map, composed of two layers: the bottom layer would represent the roads, the upper layer would represent the traffic (green, orange, and red blocks). Users may want to enable/disable the traffic layer. I don't know how to represent these two layers in MapML so that a client tool can offer that functionality. It seems that, to do that, I need to prepare 2 MapML documents, one for each layer, and combine them using <layer> tags in an HTML document. That seems convoluted for a feature that is core to the definition of a map (but maybe layers are not that core to the notion of map).

In a GIS user interface, the "map" is the basis of the user interface, and map "furniture" is supplied to aid in manipulating the layers. Although the primary client of MapML is designed to be the Web browser, there's no reason that I can see that MapML shouldn't be usable by GIS programs as well.

MapML document could also be the target of the URL bar in a browser, in a similar way that an SVG document can. In such a case, the map document is the browsing context. At that point, what is the difference between the browser and a GIS program? The program needs to provide the map infrastructure. Maybe for a browser that would be a synthesized HTML document with a element with a element referring to the MapML document, similar to how the browser treats a URL for an image. But maybe one day we could have a model in which such a MapML document could load script? I think that has a lot of potential.

If browsers support MapML, why imagine that they would wrap the MapML document into an HTML document with a <map> element and a <layer> element? They would have to create a browsing context and a DOM tree for the MapML document in any case.

Essentially, I'm wondering why there are two specs and not only one that would both define a document format and a set of elements that extend HTML to provide map support. That is essentially what happened in the end with SVG and MathML: SVG and MathML exist as separate document formats but all the elements that these specs define have been imported into HTML, see SVG and MathML.

In turn, that would mean merging the two specs into one MapML spec that defines the <map> element. Spec-wise, it may be hard to do that and still re-use the existing <map> element that HTML defines. But then, although a good idea in theory, extending the <map> element does not seem like a must in practice, and I doubt that the element is being used much nowadays in any case.

Prushforth commented Mar 6, 2018

My access to github from work has been temporarily broken, so I'm responding by email. I hope this works. UPDATE: it did not work. SLIGHTLY edited for clarity.

Some follow-up comments to clarify how I approach this (and keep in mind I don't claim any expertise there):

I really appreciate your thinking about this, as of course I can't look at it with fresh eyes.

To follow up a bit on this, the conceptual model of MapML is based on the concept of a document. The notion is that the document represents a map. The content layout for a map document follows the painter's model. If the client application has the idea of a "map", then it should be natural to manipulate layers in the user interface.
It should be natural to manipulate layers in the user interface, provided there is a way to identify layers. A MapML document, which represents a map, does not seem to define a way to identify layers that compose the map.

Many maps get by with a single layer, as optional layers complicate the user experience. The foremost objective of MapML is to represent a map at a URL. In other words, what is found at a URL for a MapML document can be interpreted as a map (based on media type semantics) and painted on a device area. I derived the model for the <map> element in part based on <img> and also <video> and <audio>. With regard to the latter two newer tags, they can have either a @ src attribute or a set of child <source> elements, from which the browser picks the one that it prefers based on the media type. The media type is the actual video, the <video> is the client application. This is similar to how I see <map> working, except that instead of being a choice of source-s the map is composed of all of the <layer>s. There's no real contract as to what a map looks like, we can only say how it should be processed. So, we define a media type with DOM-based semantics -> MapML.

The painter's model merely states that things get drawn in order. It does not help with grouping things together into a layer.

Let's imagine a traffic map, composed of two layers: the bottom layer would represent the roads, the upper layer would represent the traffic (green, orange, and red blocks). Users may want to enable/disable the traffic layer. I don't know how to represent these two layers in MapML so that a client tool can offer that functionality. It seems that, to do that, I need to prepare 2 MapML documents, one for each layer, and combine them using tags in an HTML document.

This is the preferred way such that the controls of the map have a thing to enable/disable. Taking a quick peek at google shows me they take a similar approach.

That seems convoluted for a feature that is core to the definition of a map (but maybe layers are not that core to the notion of map).

Layers are fundamental to GIS and Web mapping. This is why they are the target of URLs in MapML.

In a GIS user interface, the "map" is the basis of the user interface, and map "furniture" is supplied to aid in manipulating the layers. Although the primary client of MapML is designed to be the Web browser, there's no reason that I can see that MapML shouldn't be usable by GIS programs as well.
MapML document could also be the target of the URL bar in a browser, in a similar way that an SVG document can. In such a case, the map document is the browsing context. At that point, what is the difference between the browser and a GIS program? The program needs to provide the map infrastructure. Maybe for a browser that would be a synthesized HTML document with a element with a element referring to the MapML document, similar to how the browser treats a URL for an image. But maybe one day we could have a model in which such a MapML document could load script? I think that has a lot of potential.

If browsers support MapML, why imagine that they would wrap the MapML document into an HTML document with a element and a element? They would have to create a browsing context and a DOM tree for the MapML document in any case.

When the URL bar points to a MapML document, I think you're correct ( I was trying to convey that situation with my hoped-for future in which a MapML document as the browsing context could load script, but I probably didn't expend enough ink to properly describe that). Today when you point the URL bar at a png, for example, they browser does in fact synthesize an HTML document and wrap the png in it, so that's probably something simple that could be done pretty easily. I imagine getting to the point where we have our MapML semantics standardized enough to build an interoperable, scriptable DOM will take more time and effort, but I would love to get there.

Essentially, I'm wondering why there are two specs and not only one that would both define a document format and a set of elements that extend HTML to provide map support. That is essentially what happened in the end with SVG and MathML: SVG and MathML exist as separate document formats but all the elements that these specs define have been imported into HTML, see https://www.w3.org/TR/html53/semantics-embedded-content.html#svg and https://www.w3.org/TR/html53/semantics-embedded-content.html#mathml.

I agree and foresee this is the desired end state, but I didn't want to try to "take over" HTML with map semantics quite yet. In getting to that state it may be necessary to first convince the (possibly non-Web) map developer community to use MapML in their software products. As such, MapML should become an independently useful thing along the road to being a Web standard. In fact I think many browser developers would say that in order to become a Web standard it should have to prove itself by being an independently useful thing first. As such, a <map> and <layer> element would be very useful, I agree.

That being said, almost all HTML elements could be useful on a map, as part of the document infrastructure. Our first step in this direction will be to try to open the door to HTML markup within the properties of the MapML <feature><properties> element, to enable appropriate format, style and small-s semantics.

In turn, that would mean merging the two specs into one MapML spec that defines the element.

See above I agree this is likely to be desirable. And of course then we would have the <map> and <layer> elements in MapML :-) which we could use to define overview / key maps, controllable layers-in-layers etc.

Spec-wise, it may be hard to do that and still re-use the existing element that HTML defines. But then, although a good idea in theory, extending the element does not seem like a must in practice, and I doubt that the element is being used much nowadays in any case.

I agree but a) the existing <map> element has almost perfect primitive semantics to allow the introduction of more 'advanced' semantics like we're talking about. It can be used as a fallback for browser that haven't implemented the MapML spec (the web platform players don't all move in unison, as I've discovered), which is important for HTML authors. b) we shouldn't pollute HTML with elements which do variations on a theme, as we make it more difficult for people to become HTML authors (cognitive loading). For example, we would not introduce a new <table> element, should we want to enhance it, now that people should no longer use it for layout since so much effort has gone into developing CSS for layout over the years. We would see that as confusing for HTML authors, I think. Same for map, as I see it. It works for one use case, let's keep it working for that while using it as the basis for more modern ways of doing things.


Changelog for QGIS 3.16¶

Another great day for the QGIS project! The new long term support release brings a wide range of features to both QGIS Desktop and QGIS Server. This release brings a wealth of new options for 3D mapping, mesh generation from other data types, additional spatial analysis tools, symbology and user interface enhancements to name but a few! A host of tools have been incorporated into the ever-expanding processing framework, and the QGIS browser now supports advanced database interaction functionality that was previously reserved for the DB Manager plugin. These are a few of the improvements that have been introduced from this release, and users of the previous LTS will find a massive number of new features available since 3.10. We are pleased to detail some of the additional highlights of this new release below.

We would like to extend a big thank you to the developers, documenters, testers, and all the many folks out there who volunteer their time and effort (or fund people to do so) to make these releases possible. From the QGIS community, we hope you enjoy this release! If you wish to donate time, money, or otherwise get involved in making QGIS more awesome, please wander along to QGIS.ORG and lend a hand!

QGIS is supported by donors and sustaining members. A current list of donors who have made financial contributions large and small to the project can be seen on our donors list. If you would like to become an official project sustaining member, please visit our sustaining member page for details. Sponsoring QGIS helps us to fund our regular developer meetings, maintain project infrastructure, and fund bug fixing efforts. A complete list of current sponsors is provided below - our very great thank you to all of our sponsors!

QGIS is Free software and you are under no obligation to pay anything to use it - in fact, we want to encourage people far and wide to use it regardless of what your financial or social status is - we believe empowering people with spatial decision-making tools will result in a better society for all of humanity.


Sunday, July 26, 2020

Biden is Winning the Money Race

The New York Times has mapped out the campaign donations to Biden and Trump over the last three months. In Trump vs. Biden: Who’s Winning the Money Race in Your ZIP Code? you can view an interactive map which shows which candidate is raising the most money in different parts of the country.

Zip-code areas on the NYT interactive map are colored to show whether Trump or Biden had more individual donors in the area from April 1 to June 30, 2020. Across the whole country Biden had around 400,000 more individual donors than Trump. In general the map reveals that Trump is mostly popular in rural areas, while Biden is more popular in urban areas and along both the east and west coasts.

Biden had more individual donors in 26 states and Washington D.C.. Trump had more individual donors in 24 states.


Programming patterns with web mapping APIs

If you distinguish yourself within your organization as a person who can develop web maps, it's likely you'll eventually be called upon to use more than just one of the APIs described in the previous section. As noted, project circumstances and requirements can force the selection of different APIs for differing endeavors. As a programmer, it's important to understand the general structures, patterns, and architectures behind the APIs and languages you use, so that you can learn new ones on the fly. Technology is always changing, and you will limit your utility if you tie yourself to a single development mode.

The following section describes some patterns and features that are held in common among many (but not all) of the web mapping APIs described earlier. I include this section before diving into OpenLayers, so that you get an idea of what things are not unique to OpenLayers when we begin looking at the code. However, I also include example snippets to show how the concept is implemented in OpenLayers.

Nearly all pages that use web mapping APIs include the following:

References to JavaScript files and stylesheets

Before you can get off the ground, your HTML page needs to include a <script> tag pointing at the web mapping API's JavaScript files. Be aware that the more JavaScript you are referencing, the longer it will take to load your page. Some APIs are slimmer than others (hence a name like ModestMaps) but may offer fewer features. Be aware that OpenLayers is one of the largest APIs in functionality and loading time. When adopting one of the larger APIs, some developers build and reference their own smaller version of the API that contains just the functions they want to offer.

There are a couple of ways to reference the API. One approach is to download and host the API on your own server, thus minimizing load times and allowing you to customize the API. The second approach is to reference the API on someone else's server. Sites called content delivery networks (CDNs) specialize in hosting commonly-referenced APIs. This is what a CDN URL looks like for OpenLayers, referenced within a script tag within the page head:

In this course, we'll reference OpenLayers through the CDN, for simplicity. However, be aware that if you were developing an internal application, needed full control over the APIs hardware, or needed to customize the API in any way, you would need to download and host the API yourself.

Many web mapping APIs offer some stylesheets that can get you started with making nice-looking applications. You can reference these stylesheets in the form of CSS files, either by hosting them on your own server or using a CDN. In this course, we will use the stylesheet from the OpenLayers examples and put it on our own server, rather than using the stylesheet from the CDN. However, for reference, the stylesheet from the CDN is brought into the page within the head using syntax like this:

The map div and object

When you want to put a map in your page, you will typically carve out some space using an HTML <div> tag. You then create a map object using the API and relate it to your div.

For example, with OpenLayers, you can create a map div like this in the body of your page.

Elsewhere in your page, in your JavaScript code, you can can create an OpenLayers.Map object and relate it to the div. The OpenLayers.Map constructor takes the div name as an argument.

With this approach, you can potentially put multiple maps in your page. Each map would likely have its own div and OpenLayers.Map object.

The map also has a spatial reference system associated with it that affects the appearance of the map and determines the format of the coordinates that you use. Here's a little more complex example that shows how you could explicitly define the coordinate system of the map to use the common web-friendly Mercator projection:

When you invoke the OpenLayers.Map constructor, you can optionally pass in a JavaScript object containing a whole realm of optional parameters. The above example takes advantage of this to set the projection to EPSG:900913, or spherical Mercator.

The map contains methods for adding layers, getting the current layer set, centering the map, zooming to given coordinates, and so forth. In many web mapping APIs, the map is one of the most powerful objects. Whenever you adopt a new mapping API, take a look at the reference documentation for the map object to understand what it can do and the syntax for invoking the most common methods.

Layer objects

Most web mapping APIs provide ways to define layer objects, which you add to the map object one by one to create your mashup. It is very important to note that a layer, in this sense, could represent a web service such as a WMS or tiled service that itself contains many underlying data layers. However, you would only need one layer object to bring this type of web service into your map. Other layer objects that reference single data files, such as KML or GeoJSON, are simpler to conceptualize.

In many web mapping APIs, the layer is an abstract class offering a set of common properties, and is exposed to the developer only through more specific classes. Take a look at the properties offered in the OpenLayers.Layer class. These include projection, units, scales, attribution, and other properties found in all layers. Now look at the properties of some of the more specific derived classes such as OpenLayers.Layer.WMS and OpenLayers.Layer.Vector to see some of the more specific properties associated with these layer types. You will typically be working with the API help documents at this lower level however, it is important to remember that you still have all the properties of the Layer class available to you whenever you use any of these specialized layer types.

When you create a new layer in OpenLayers, you're generally expected to provide the URL or file path containing the source data for the layer. The layer will not show up until you call a function on the map that adds it. Here's one way you could create a layer referencing a WMS and add it onto your basemap:

Don't worry if the meaning of all the parameters above is not immediately apparent. The important thing is to recognize that the layer required you to supply a URL and a layer name before it could recognize the WMS. Other properties such as singleTile and isBaseLayer just provide details how the layer is to be displayed in the map.

The addLayer method on the Map object is what actually adds the layer onto the map and makes it visible. If you call addLayer again and pass in some other layer, it will be placed on top of the first layer.

Some layer types like OpenStreetMap have commonly known URLs, thus OpenLayers includes a specific class that lets you type in the user-friendly name of the layer rather than its URL. For example, here's how you could add the basic OpenStreetMap tileset to your map:

Note the use of the class OpenLayers.Layer.OSM specifically for adding OpenStreetMap data. The class is able to interpret "Simple OSM Map" and you are not required to supply the URL.

Layer styling mechanisms

Layers that come already drawn by the server, such as tiled maps and WMS images, already have styling applied, but for layers drawn by the browser such as GeoJSON or GeoRSS, you must define how the layer will be styled. Web mapping APIs typically offer a group of properties that you can set on a layer like this to define how the browser should draw it. These properties include things like fill width, fill color, outline width, outline color, and so forth. Many APIs allow you to use a custom image for a marker, rather than placing a simple dot.

The OpenLayers example below shows how you could add a GeoJSON layer of grocery stores to your map and style it with a shopping cart icon saved in an SVG (scalable vector graphics) file called grocery.svg. This could just as easily be a PNG file or other rasterized image type.

The result might look something like this when put on top of a basemap layer:

Don't worry if all the code above is not completely clear to you yet. Just make sure you can see where the style is being defined via a JavaScript object. In Lesson 7, you will get some more exposure to GeoJSON and styling browser-drawn graphics.

Events and interactive elements

Web mapping APIs offer interactive elements that help your map become more than just a static picture on an HTML page. The map and layer objects described above typically allow you to run code in response to certain user actions, such as clicking the mouse. The user action is called an event (or firing an event). The code you run in response is called the event handler, and it typically goes into its own function block of code. Sometimes the event can supply arguments to the handler function that tell things about the event, such as the screen coordinates of the mouse click that fired the event.

For example, you might instruct the map to "listen" for a mouse click event. You could then write a handler function that takes the screen coordinates of the event argument (in other words, the coordinates of the clicked pixel) and converts them to map coordinates, then writes the coordinates into a label in the HTML page so they can be seen by the user. An even greater measure of interactivity could be achieved by wiring up this handler function to a hover event, instead of a click. You would then get the effect of always seeing the coordinates of your mouse as you moved it around the screen.

Web map users often want to obtain more detailed information about specific features in the map. It is very common to handle a click event by showing a popup window with more information about the clicked feature so common, in fact, that many web APIs have special classes and methods for popups that don't require you to write the typical amount of event listening logic. You will learn more about popups in OpenLayers in future lessons in this course.

Sometimes popups are too limited in space or complexity for the content you want to show. Even if your mapping API allows you to cram large images or tabbed interfaces into a popup, it often makes more sense to show this type of content in an HTML div elsewhere on the page. Web mapping APIs allow you to perform queries on a clicked point and retrieve attribute information from the clicked features (often as part of a handler function like the ones mentioned above). You can then do anything you want with this handler function in order to display the information in HTML. You might even pass the information to a different specialized API that draws charts, queries Wikipedia, finds nearby homes for sale, and so forth.

Another common piece of desired interactivity is the ability to switch layers off and on. Remember that in this sense, a "layer" is an entire web service. It is obviously not possible to toggle the visibility of individual sublayers inside a tiled map because all the layers are "burned into" the tiled image. However, you could turn off the entire tiled map, or turn off a WMS or GeoJSON layer placed on top of it.

Because the OpenLayers Map object allows the retrieval of all its layer objects and the Layer object has a setVisibility method, you can write a relatively simple function to toggle the visibility of a layer. Here's an example of a function that toggles layer visibility when a user clicks a table of content element:

The function finds all the layers with the given name and takes the first one (index 0) in the case that multiple layers have the same name (you should avoid this anyway). It then checks whether the layer is already visible and then calls the setVisibility method to toggle the visibility off or on accordingly. This type of function could be wired up to any type of button or checkbox that you want to construct.

Now that you are familiar with the different elements of a web mapping API and have seen how these are expressed in OpenLayers, we'll move forward and take a look at some full functioning examples.


New Features

On this page you can read details about the new features introduced in each AIMMS Feature Release.

For an extensive list of changes and fixes in all releases, see the Release Notes.

To download AIMMS, visit our Download Center.

AIMMS 4.80 Release

Feature(s) introduced in AIMMS 4.80 (June 2021)

The following exciting improvements have been made to the AIMMS WebUI:

WebUI: Dialog Page Improvements

  • Dialog pages can now also use the new Grid Layout to improve the look and feel in Apps.
  • There is a custom sizing option added next to the small, medium and large defaults allowing for larger or specific dialog sizes (this requires use of the new Grid Layout).

WebUI: Side Panel Improvements

  • Side panels can now also use the new Grid Layout to improve the look and feel in Apps.
  • Each side panel can now include a custom-colored icon to identify the side panel tabs more easily for the App users.


WebUI: Selectionbox-V2 Widget Introduced as Experimental Feature
A more efficient implementation of the Selection Box widget is introduced in this AIMMS version as an experimental feature. The widget uses less resources than the current implementation and supports a far larger number of items in the dropdown (tens of thousands). Please note: a selectionbox-v2 requires the page to use the Grid Layout.

The following improvements have been made in the algorithmic capabilities of AIMMS:

Solver Updates
In this release, we have included the following solver updates: CPLEX 20.1, CPOptimizer 20.1, and Gurobi 9.1.2.

Improvements in GMP Functions
The optional argument ‘merge’ has been added to the procedures GMP::Solution::SendToModel and GMP::Solution::SendToModelSelection. This argument can be used to merge the values of the variables and constraints in a math program with a solution in the solution repository of a GMP. Furthermore, the functions GMP::Solution::GetColumnValue and GMP::Solution::GetRowValue can now also be used to retrieve information regarding basic columns and rows.

Next to the improvements already mentioned, AIMMS 4.80 also offers the following:

Linux Repo Libraries Included in aimmspack-Files
If your application uses libraries from the online library repository, you can now choose to include the sources of these libraries in the .aimmspack for both Windows and Linux this used to be only available for Windows libraries. This extension makes the deployment on the AIMMS Cloud more efficient as any online sources do not need to be downloaded during startup.

Improved Case Loading TimeThe time it takes to load an AIMMS case has been reduced, especially when running on a Linux system (up to 5 times).

AIMMS 4.79 Release

Feature(s) introduced in AIMMS 4.79 (April 2021)

Required Unit Attribute for Libraries and Modules
AIMMS Libraries and Modules now offer the attribute required unit. By specifying here which unit(s) the Library or Module uses, you no longer have to declare these units in the Library or Module itself. Instead, they are automatically declared for you in an automatically generated dedicated section in the main model. Beside the convenience this gives, it also prevents compatibility problems between Libraries and Modules which need (and declare) the same units. For details, see the Language Reference. For more information about the background and typical use, see this AIMMS Community article.

WebUI: Tooltip Annotation for Sets
AIMMS already featured the possibility to specify custom tooltips on the data in your WebUI widgets. In this release we have added the possibility to do this for header data (Table headers and the x-axis labels of the Bar, Line and the Bar-Line charts). This functionality offers the ability to provide more clarity for your end-users when interpreting the chart. For details, see the documentation.

WebUI: String Parameters in the Text Widget
Up until this AIMMS version, the content of the Text widget was static text. Although useful, we have greatly enhanced the flexibility of this widget by providing for dynamic content through the use of a string parameter. The result is a Text widget which can be dynamically updated depending on the state in your WebUI app.

WebUI: Download Chart Contents as an Image
Sometimes it is more practical to quickly share the content of a WebUI widget from your App by simply providing it as an image. Previously, this could be done by taking a screenshot of your page and cropping out the required area. Now the WebUI offers a button in the widget header with which you can easily download the content of the widget as an image file. For more info, see the documentation.

Download the chart as an image file

AIMMS 4.78 Release

Feature(s) introduced in AIMMS 4.78 (February 2021)

Automated Scaling
The scaling tool can, going forward, be directly used in a (GMP) solve statement. This removes the immediate need to adjust the actual model using the proposed scaling factors (introduced in 4.74) and makes scaling valuable beyond a pre-solver.
By activating the automated scaling option (there are a number of options on how to scale), the model will be scaled automatically before sending it to the solver in addition, results will be scaled back to be able to be interpreted correctly. Although this is convenient, it is good to realize that these scaling steps takes place at each solve. If you have a model that needs constant scaling, we recommend you to scale the actual model so you can turn off the auto scaling to reduce the total solve time (scale + solve + scale back).

Solver Updates
Three solvers have been upgraded to a newer version:

In addition, different option settings can now be used for the optimization problems, corresponding to different objective priorities. CPLEX and Gurobi use those settings during the optimization of a multi-objective problem.

WebUI: App Management as Experimental Feature
AIMMS 4.78 comes with new App Management tooling that allows you to easily rename and copy widgets as well as move them between pages in your Web Apps. It is available as experimental feature. We expect that this will improve your speed of building and changing Apps drastically, as you do not need to rebuild widgets from the ground up, or – as we noticed some users were doing – use some manual trickery in the webui.json file.

WebUI: Table Filtering Tolerances
To improve the Table filtering, a certain tolerance has been added when comparing numerical values, resulting in a better user experience. This is especially important for using (in)equalities in a filter.

WebUI: More Efficient Communication
The communication of resources to the browser has been made more efficient. For more details, see this community post.

AIMMS 4.77 Release

Feature(s) introduced in AIMMS 4.77 (January 2021)

Solver Updates

  • CPLEX 20.1 (CPLEX uses a new numbering, which is now now based on the year of release) comes with performance improvements for mixed integer programming (MIP) models to provide better solutions more quickly.
  • CONOPT 4.1 has a few bug fixes.
  • Gurobi 9.1 (version 9.1.1) comes with performance improvements for LP, MIP, MIQP and MIQCP models.
  • CP Optimizer 20.1 comes with improvements to constraint programming models with variables that have large domains.

WebUI Date/time Picker and Time Zone Support
The WebUI date/time picker and the time zone support (both introduced in AIMMS 4.75 as experimental features) are now officially supported features. This means that this functionality is present by default from AIMMS 4.77 onwards.

The DateTime Picker for the WebUI.

New Implementation of the Case Mechanism
The code to read and write case files has been completely re-written This should not have any negative impact on existing models. and includes a few fixes related to the order in which data was read how definitions were evaluated during reading. The format of the case files has not been changed and thus is still compatible with older AIMMS versions. This rewrite should not impact case usage in your models, but if you encounter any problems because of this change, please let us know as soon as possible.

JIT (Just-in-Time) Compilation
There is a new project option “JIT_Body_Compilation” to enable the new feature: Just-In-Time body compilation. This skips the compilation of the body attributes of procedures and functions that are not required at startup, which decreases the startup time of your models. Procedures and functions are compiled just before their first actual run. This also means that Procedures and Functions that are in the application, but not used, will not be unnecessarily compiled. You can enable this feature by setting the new option ‘JIT_Body_Compilation’ to ‘On’.

Help On menu Links to Online Version of Manuals
The links to the Language and Function Reference which can be accessed through the Help On menu in the AIMMS IDE, now point to the online version of these manuals instead of to static PDF versions of them. This has the advantage that the information that is displayed is always the latest version.

AIMMS 4.76 Release

Feature(s) introduced in AIMMS 4.76 (October 2020)

New Bar-Line Chart Widget in WebUI

W e have extended our WebUI framework with the Bar-L ine Ch art widget to improve the possibilities of showing your AIMMS model data to your end users. The widget makes it possible to add a line identifier and a set of bar identifiers (stacked or grouped) as can be seen in the example below. Read more in the documentation .

The new Barline Chart widget.

AIMMS 4.75 Release

Features introduced in AIMMS 4.75 (September 2020)

Knitro 12.2 has been added to this release of AIMMS. This version of the solver is expected to bring you significant enhanced performance in medium – and large – scale models (50% or more in some cases). When using the multi-start, multi-algorithm or tuner features, parallelism is enabled by default now. Next to more extensive presolving by default, it also offers a new ‘ weak Wolfe line search ’ option, which can prove useful when solving non-smooth unconstrained models. Please let us know how Knitro 12.2 works for you!

Table Filtering in WebUI

Focusing on the most important aspects of your data displayed in WebUI Tables just got even easier: you now have the possibility to add filters to limit the rows and columns to be displayed, based on various criteria. For example, when showing transport costs for a big set of cities, you can set up a filter showing only the rows containing a particular city and another filter showing only those rows for which the cost is higher than $1 , 000. Created filters can easily be enabled, disabled or deleted.

Adding data filters to a WebUI Table

Grid Layout in WebUI (Experimental)

We are in the process of improving the way in which you can design your WebUI pages. We are proud to offer our work on this new Grid Layout as an experimental feature in this release. Using the new functionality based on GridCSS , you have far better control over where widgets will be placed on your WebUI pages, by using pre-defined or custom layout templates. It allows for a more efficient use of your screen real estate and the resize behavior of pages has been improved as a result, too. A l though we realize this feature is not yet complete (e.g. currently only regular pages support this new layout dialog and side panels are still ‘old style’) , we are looking forward to your initial response and experience.

The New Grid Layout on a WebUI Page

DateTimePicker in WebUI (Experimental)

The WebUI now offers an easy way of selecting dates/times (calendar elements) , with a dedicated DateTime Picker. Up till now, this had to be done using a generic dropdown or select widget. The DateTime Picker will listen to the format of the calendar elements showing only hours and minutes if needed.

The New DateTime Pickers for the WebUI.

Timezone Support in WebUI (Experimental)

Next to this, we have added functionality to streamline working with the same WebUI App from different time zones. This allows each user to see time-related data i n their own time, or for a developer to decide goo to build an application in a specific timezone . As adding timezones is not trivial and requires a good structural setup, we have also created a best practice guide for you, which you can read here.

AIMMS 4.74 Release

Features introduced in AIMMS 4.74 (June 2020)

Scaling linear models in the Math Program Inspector

Scaling your models can be important in case of numerical instability. Instead of making the scaling factor determination a manual exercise, AIMMS will now do this for you by offering a Scale Model action that is available to developers in the Math Program Inspector (MPI). It can be used to scale linear optimization models and will determine scaling factors for all (symbolic) variables and constraints. Results can be viewed in the Scaling Factors tab, and the Resolve action allows you to resolve the model using the new scaling factors to see the impact (inside the MPI tool). If you like what you see, you can decide to incorporate the scaling factors into your original model (no changes are made to your model). This part is not automated as developers may have their own preferences on how to do this (e.g. by using units, or by explicitly adding the scaling factors). The example below shows the Matrix View of the original model on the left side and of the scaled model on the right side. Scaling the model resulted in a significant decrease in the maximum constraint violation, and in a large decrease in the maximum solution value of a variable (in absolute sense).

ODH-CPLEX Solver Updated to Version 5.0

The solver ODH-CPLEX 5.0 is now available in AIMMS. It uses CPLEX 12.10 underneath, whereas the previous version (4.0) used CPLEX 12.8. The new options for ODH-CPLEX 5.0 stem from the CPLEX part. Also, for some MIP cases, the results obtained by ODH-CPLEX 4.0 were not deterministic. With the new version, they are.

WebUI Item Actions

The Item Actions, which were already an experimental feature in AIMMS 4.73 for the table, are now an official feature in AIMMS 4.74 and available for all data and chart widgets. It allows you to pull up a context menu in all kinds of widget types for specific element values ideal to e.g. allow specific actions on a cell, or add actions to a node or arc in a Map (e.g. activate/de-activate a depot, or pop up a dialog with additional details for a particular transport arc). For all the details, please refer to the documentation.

Improved Bubble Chart Widget

There have been some improvements to the Bubble chart widget. The formula for calculating the bubble sizes was updated and improved. Sizes are calculated based on the area, just like in the Map widget. Also, we added a maximum reference size for the user to set, to have more influence on the final size of the bubbles.

Missing Values and Areas in Line Charts

The Line chart widget now offers the option to show the area under the line chart. What’s more, missing values (so-called NULLs) are now no longer displayed. In previous versions, they were displayed as zero-valued points in the lines, which was not a correct representation. In addition, you can now select a line chart to show the areas underneath the lines.

Sorting Dates in a WebUI Table

The sorting algorithm in the Table widget has been adjusted such that values that are based on an underlying AIMMS calendar are sorted on actual dates (and not alphabetically). Up to 4.73 this could lead to, for example, August 1 preceding July 1. There is no change needed by the developers.

Online Function Reference Used in Help On

The ‘Help on…’ feature in the AIMMS IDE (select a function and hit Right Click) now takes you to the online version of the AIMMS Function Reference. Previously, the included .pdf document was opened. By using the online version, you can be assured that you are always pointed to the most up-to-date information. BTW, the complete function reference is available here.

AIMMS 4.73 Release

Features introduced in AIMMS 4.73 (April 2020)

Many New Features in the WebUI Map Widget

In this AIMMS 4.73 Release, the Map widget in the WebUI has been the main point of focus. We created some exciting new features, making this widget even more versatile than it was before. Here is the complete list of the additions and changes:

  • We have upgraded the framework that we use internally for the Map widget to Leaflet JS. This upgrade allows for better support and the ability to develop more features including many of the ones below.
  • The Map widget now offers a so-called ‘Heatmap’. For a set of coordinates on your map, you can specify a ‘heat value’. Based on these values, a gradual coloring is applied between the points represented by the coordinates. This feature gives immediate visual cues about the data presented in your map.
  • The map tiles will be served from Omniscale when the application is running on localhost (app developer, or on local PRO) and when the application is deployed on the PRO cloud. If customers have deployed the application on-premise using a different domain the tile server will roll back to OpenStreetMaps. Omniscale is available only for the upgraded map version.
  • If you already use services from Google Maps, it is possible to override the default map provider in AIMMS with Google Maps. This way, the Map widget will display the content provided with Google Maps.
  • We have introduced Item Actions on the nodes and arcs of the Map widget as an experimental feature. For details, please see the documentation.

Arc Improvements

  • We extended the possibility to use the store focus mechanism to include arcs (both source and destination). This means that you can, upon selection of a node and/or arc in the Map widget, ensure element parameters will be set. These changed values can be used to e.g. show sliced data around the Map widget or trigger other data to be adjusted.
  • You can now add annotations to arcs in your Map widgets in a straightforward way. This provides flexibility in selectively styling the arcs, to give even clearer visual cues to your application users and reducing the need to start using custom CSS.
  • Arcs are now drawn in a clockwise manner: arcs drawn from left to right (west to east, north to south) will curve towards the top, and right to left (east to west, south to north) will curve towards the bottom. This is due to the new framework, but also offers the benefit that bi-directional arcs no longer overlap.
  • The labels displayed on the arcs also look crisper compared to earlier versions of the Map widget.

Node Improvements

  • Both the nodes and arcs can now be provided with a custom HTML tooltip, specified – similar to e.g. the bar chart – through the AIMMS model. This greatly enhances the possibilities to add context to data when hovering specific nodes or arcs.
  • In previous versions of the Map widget, the nodes were always displayed by a colored circle. Now we made it possible to display an icon in your nodes. The icons are specified in the AIMMS model, making this as flexible as possible, from a ‘one icon-fits-all’ approach to assigning each node a different icon.
  • App developers can now control the order of the nodes drawn based on the node-set order. Important: The first node-set will be drawn over the other node-sets if there are overlapping nodes.
  • We introduced a Maximum Reference Size, which offers you more flexibility in sizing the nodes on your map. Instead of an automatic size calculation, relative to the size of the biggest node, you can now specify a size yourself to base this calculation on. This is specifically handy in case you have multiple node sets and you want them all in similar size, or you care about controlling node size.
  • We have changed the node sizing formula. The sizes of nodes for a node-set are relative to their surface area, whereas earlier they used to be based on the radius in pixels. This assures that relative size is visually correct (a demand node of say 50 will be twice as small in area as a demand node of 100).
  • As node display is based on relative size, we removed the display of nodes with size 0 as that conflicts with what is expected. If it is important to display nodes of size 0, one has to adjust for it via additional node sets.

Should you wish to not use these new features already, you can do this by checking the “ignore the map upgrade” checkbox in the experimental features dialog (reachable by CTRL+SHIFT+. and then clicking the ‘crossed hammers’ icon in the WebUI menu bar). Please be aware that any new features in upcoming AIMMS releases will be developed for the upgraded map only.

WebUI Upon Change Procedures through Annotations Mechanism

Now you can specify your Upon Change procedures for the WebUI through the AIMMS annotations widget. Previously, you had to do this with AIMMS procedures using a specific naming convention, potentially leading to unexpected problems when renaming identifiers.

AIMMS 4.72 Release

Here you can read about the new features introduced in AIMMS 4.72. For a list of changes and fixes, see the Release Notes. To download, visit our Download Center.

Features introduced in AIMMS 4.72 (March 2020)

New List Widget in WebUI

In this release we introduce the new List Widget as an experimental feature. The idea of this widget is that you can generate a list of (grouped) items to e.g. build up a set of Tasks, develop a custom Legend, or find other means (I am sure you can think of other ways to use this). All items can be made interactive by associating them with AIMMS procedures (upon click). Like other workflow items, such as Status Bar and Page Actions, the List Widget items are generated via the model and can thus by super dynamic and change upon the status of the application or data, user, etc. See also our earlier discussion at the AIMMS Community. For details on the widget itself, please see the documentation.

CPOptimizer 12.10

We have upgraded our Constraint Programming solver to the latest available version 12.10, which should bring performance benefits in specific cases.

New R Packages For AIMMS Cloud

We extended the packages for R on the AIMMS Cloud with the “Caret” package (short for Classification And REgression Training). It is a set of functions that attempt to streamline the process for creating predictive models and contains tools for: data splitting, pre-processing, feature selection, model tuning using resampling, and variable importance estimation.

WebUI State Support

We are introducing the CurrentPageID for WebUI feature so modelers can benefit from the location (i.e. current page/browser tab) of the user of the application and adjust e.g. the workflow accordingly or run specific validation routines. Initially, this will also be offered as an Experimental Feature so we can get feedback on the behavior. For more information see the documentation.

Experimental Features in WebUI

Activating Experimental Features can be done by hitting the 3-key combination “CTRL-SHIFT-.” in your WebUI app at this moment, a new icon appears on top to show a dialog to manage your Experimental Features. It is good to be aware that we release new features this way more often as it allows us to release faster to the public and collect feedback, while still having an option to structurally correct features in case the feedback we receive requires this. Hence, the status of an Experimental Feature is less formal and users should be aware of this (it does not fall under our SLS). We try to upgrade Experimental Features to standard features as soon as possible. In particular cases, it does happen that Experimental Features will not make it to the a formal release in the end.

AIMMS 4.71 Release

Here you can read about the new features introduced in AIMMS 4.71. More details can be found in the release notes. AIMMS 4.71 can be downloaded here.

Features introduced in AIMMS 4.71 (January 2020)

Better Way of Handling Flags, Tooltips and Annotations

The existing methods of adding Flags, Tooltips, Annotations and Text annotations have been deprecated. The new way of doing it, using the annotation section in the identifier attributes, is a more elegant way and will make the model more flexible with respect to choosing which identifiers should be the annotations (and name those to your liking). In addition, it will make it clear inside an identifier declaration which annotations exist for it. We ask you to convert your model to the new way of defining annotations as soon as possible (at this point warnings are generated in case you use the old-style annotations).

Convenient Excel Functions to Determine Data Ranges

The Excel Library has been extended with 4 new functions, which make it far easier to determine the range on a sheet that contains cell data. The functions FirstUsedRowNumber, LastUsedRowNumber, FirstUsedColumnNumber and LastUsedColumnNumber can be called to check, for example, which is the first column in the sheet which contains data. In combination with AIMMS’s functions to convert column numbers into names, this offers a powerful mechanism to dynamically determine data ranges.

Option to Disable Implicit Database Table Mapping

There is a new property called ‘No Implicit Mapping’ added to the Database Table. When executing a read or write statement on the table, implicit mapping occurs by comparing the column names in the table which are not already bound by the explicit mapping with identifier names in the model. This is not always the desired behavior and can lead to surprises in specific cases, so now this implicit mapping can be turned off.

Inspect Stochastic Models in The Math Program Inspector (MPI)

The Math Program Inspector has been adjusted to use the GMP interface to communicate with the underlying models. This change, next to having an improved code base, also now allows users to inspect stochastic programming models (math programs generated with the function GMP::Instance::GenerateStochasticProgram) using the MPI.

AIMMS 4.70 Release

Here you can read about the new features introduced in AIMMS 4.70. More details can be found in the release notes. AIMMS 4.70 can be downloaded here.

Features introduced in AIMMS 4.70 (December 2019)

New Statusbar Functionality in WebUI

Announced previously in Product Owner updates and shared via our Community already in a pre-release, AIMMS now offers the ability to compile content for the status bar (bottom bar of your WebUI App).

The content can be based on the behavior or status of the Application that you believe is important to continuously share with your users. Here, you can think of adding items like current data, recent solution details, or general KPIs. Some additional ideas are provided in our design system here and a concrete example is shown below. The status items can, next to headers, text, icon, color and tooltip, also contain a link to a procedure allowing you to generate an activity such as running a procedure that opens a DialogPage (e.g. to show much more details of a solution). Many more use case can be thought of (we love to see yours!). For more details on the setup and usage, please check out the AIMMS WebUI Manual. The Status Bar will be offered via the Experimental Feature tab at this point in time.

New Aggregator Types in WebUI

We added new aggregator types to the WebUI widgets. For example, you can now distinguish between aggregators for the total data covered by a widget, or for only the data currently displayed. For details, see the documentation.

Next to these features and all the items mentioned in the release notes for AIMMS 4.70, we did a lot of work ‘under the hood’ of the AIMMS WebUI, to lay a strong foundation for the future.

AIMMS 4.69 Release

Here you can read about the new features introduced in AIMMS 4.69. More details can be found in the release notes. AIMMS 4.69 can be downloaded here.

Features introduced in AIMMS 4.69 (September 2019)

Offline Support for RepositoryLibraries

AIMMS now offers the possibility to include your versions of the repository libraries when exporting your model to a .aimmspack file. Using this feature, you can make sure that your model is fully compatible with the set of libraries that it uses. Furthermore, if the model will be deployed on a machine with restricted network access (such that it cannot download any repository libraries), it can still work as you intended.

Widget Actions for Scalar, Legend and Slider widgets

The Widget Actions feature has now also been applied to the Scalar, the Legend and Slider Widgets.

WebUI Cog Wheel Inside Small Widgets

We have changed the position of the widget cog wheel for some smaller widgets (such as button, label, upload, download and selection box). It is now displayed inside the widget, upon hovering it, making overlap situations a thing of the past.

Showing/Hiding CSV Downloads in WebUI Tables

The button which allows your app users to download the contents of a Table widget as a .csv file, can now also be hidden by the app developer.

AIMMS 4.68 Release

Here you can read about the new features introduced in AIMMS 4.68. More details can be found in the release notes. AIMMS 4.68 can be downloaded here.

Features introduced in AIMMS 4.68 (July 2019)

Page Actions in WebUI

We added Page Actions to the WebUI, which help your users to get quick access to actions that are needed often, while at the same time reducing unnecessary clutter on their WebUI pages. For more details, see the documentation.

Name Change Support in the WebUI

In previous versions of AIMMS, the WebUI was not automatically updated when you made name changes in AIMMS identifiers. From 4.68 onwards, these are propagated to the WebUI as well.

Page Leave Procedure for WebUI

Next to the existing ‘Action Upon Load’, the WebUI now also offers an ‘Action Upon Leave’ for each page. Using this feature, you can specify a procedure which is automatically executed upon leaving the page. It also features a mechanism to perform checks and return a status code, determining whether the page may indeed be left, or something still needs to be done by the user in order to leave it. For more details, see the documentation.

SetProgressMessage Function for WebUI

AIMMS has been extended with a procedure ‘webui::SetProgressMessage’ which allows you to replace the text of the ‘busy’ message in the WebUI with something more suitable to your specific situation. You can update/change this message multiple times during execution. For details, see the documentation.

Experimental Feature: Workflow Support in WebUI

We are working on the Workflow Panel feature in the WebUI. This allows you to define clear workflows which guide your users through your application. It comes with a clear overview of these workflows, including the status of the steps that the user needs to do to get a specific task done. For a detailed description of the feature, see the documentation. Currently, we have pre-released this feature to a small group of customers who requested access to it to become alpha-testers. If you are interested in trying out this feature as well, please contact AIMMS support.

AIMMS 4.67 Release

Here you can read about the new features introduced in AIMMS 4.67. More details can be found in the release notes. AIMMS 4.67 can be downloaded here.

Features introduced in AIMMS 4.67 (May 2019)

Gantt Chart Improvements in WebUI

In this release, we have made the following of improvements to the Gantt Chart widget of the WebUI:

  • It is now also possible to change only the start date of a job by a single drag action on the left side of a bar. Previously, this was possible, but it required you to first drag the whole bar to the desired start position, and then to re-adjust the end date to what it was before.
  • Two new options have been introduced: Minimum Resource Height and Maximum Resource Height. With these, you can set the minimum and the maximum height of the bars in the Gantt chart. If the values that you provide lead to rows of bars falling out of the widget area, a vertical scroll bar will automatically appear.

Simplified WebUI File Structure

We made a fundamental change in the storage of WebUI pages and widgets. Where each page and widget was previously stored in a separate folder, currently the entire application including *all pages and widgets* is stored in a single webui.json file. When opening your application in the IDE, the webui.json file will be automatically generated from your existing setup. During the conversion, only pages and their associated widgets that are actually referenced in the WebUI page manager will be included in the webui.json file. The conversion will *not* delete the contents of the existing pages, widgets and application folders on disk, allowing you to still use older AIMMS versions, which depend on the old format. If you make changes to the WebUI using older AIMMS versions, you can delete the webui.json file, in which case it will be automatically re-generated. Changes made with AIMMS 4.67 and higher will never be visible in older AIMMS versions.

If you are using version control on your WebUI project, please make sure to add the new webui.json file, and delete the pages, widgets and application folders from version control when you don’t plan to use the project with AIMMS version 4.66 and lower any longer. The new format as a true json file will make the structure of the webui directly clear, allowing you to resolve merge conflicts in the WebUI much easier. It also makes searching where widgets are used in your WebUI application straightforward.

When deleting pages and widgets in the WebUI, these will now be deleted from the webui.json file immediately, solving the issue where deleted pages and widgets were kept on disk making it unclear which pages and widgets were actually used and which were not. The immediate removal from the webui.json file will prevent you from reverting page and widget deletions from within the WebUI. Using version control, however, you can easily revert such deletions directly on the webui.json file on disk.

If you plan to publish your existing AIMMS app(s) using AIMMS 4.67, you first need to re-export your model using AIMMS 4.67. This step creates the expected webui.json file. If you omit this step, you will get an error message upon publishing.

Next to the direct user benefits, this change will enable us to make architectural and performance improvements in future AIMMS versions.

AIMMS 4.66 Release

Here you can read about the new features introduced in AIMMS 4.66. More details can be found in the release notes. AIMMS 4.66 can be downloaded here.

Features introduced in AIMMS 4.66 (May 2019)

Widget Actions in WebUI

The WebUI has been extended with the possibility to add so-called widget actions to your widgets. Using these, you can add menu’s to individual widgets. The menu options can be linked to procedures in your underlying AIMMS model, allowing you a lot of flexibility in context-related actions. For more details, see the documentation.

Various Solver Updates

A number of solver upgrades were introduced in AIMMS 4.66:

  • CP Optimizer 12.9 has been added. CP Optimizer 12.9 is only available for 64-bit Windows (VS2017) and Linux.
  • Gurobi 8.1 has been upgraded to version 8.1.1.
  • BARON 19 has been added. BARON 19 is only available for 64-bit Windows (VS2017).

AIMMS 4.65 Release

Here you can read about the new features introduced in AIMMS 4.65. More details can be found in the release notes. AIMMS 4.65 can be downloaded here.

Features introduced in AIMMS 4.65 (April 2019)

Dialog Pages in WebUI

The WebUI has been extended with the possibility to create Dialog Pages. These act like dialogs in, for example, Windows. You can choose between three sizes for such pages and define buttons on it, next to the widgets that you want to show. For more details, see the documentation.

Page Functions for WebUI

Next to the Dialog Pages as described above, AIMMS now offers three pre-defined functions to open either Pages, Side Panels or external URLS from within your model. For details, see the documentation.

AIMMS 4.64 Release

Here you can read about the new features introduced in AIMMS 4.64. More details can be found in the release notes. AIMMS 4.64 can be downloaded here.

Features introduced in AIMMS 4.64 (February 2019)

Side Panels in WebUI

In the WebUI, you can now also add Side Panels to your pages. Side Panels allow you to put ‘controlling’ widgets to a panel on the right side of the screen, which can be opened and closed. This gives you the benefit of not having to clutter your pages with all kinds of selection widgets, allowing your users to focus better on the widgets that present your data. For more details, see the documentation.

More Robust Error Handling Implementation

In this release the implementation of the error handling system as described in the Language Reference, has been rebuilt. This has been done because the previous implementation had some problems that sometimes resulted in errors or warnings not being presented to the user. Although in most situations the new error handling works exactly the same, you might notice some differences in how errors or warnings are handled. If you think that this handling is incorrect, please let us know. Known changes/bugfixes:

  • An error in constraint evaluations during a solve did not stop the execution.
  • An Assertion with a specified Action attribute that does not contain a Halt statement, triggered a Halt anyway. This implicit Halt should only occur when the Action attribute is empty.
  • Changes in the legacy function handling (see Language Reference 8.4.3). The described options intrinsice_procedure_error_handling and external_procedure_error_handling now only have an effect on the errors for which the procedure sets the CurrentErrorMessage. If the procedure (also) uses the more modern style of raising warnings and errors then these raised warnings and errors will just be handled like any other warning or error that is raised during execution.
  • If a new error is raised during the handling of warnings and errors in a local error handler (like in the OnError clause of the Block statement, or inside the global_erroror_handler procedure) then the handling of the remaining warnings and errors is skipped and these warnings and errors are marked as handled.
  • If an external procedure (like for example the axll:: spreadsheet procedures) only raises warnings, these warnings are now correctly reported. In previous AIMMS versions these warnings sometimes just disappeared.
  • The WebUI now only displays errors and warnings that are not handled by any local or global error handler. Besides that, the various warning control options (like ‘communicate warnings to end users’) now also have an effect on the warnings shown in the WebUI. In general, this change will lead to a lot less warnings being displayed.

AIMMS 4.63 Release

Here you can read about the new features introduced in AIMMS 4.63. More details can be found in the release notes. AIMMS 4.63 can be downloaded here.

Features introduced in AIMMS 4.63 (February 2019)

Authorization Support in WebUI

We have implemented an authority mechanism, which allows you to fully control which of your model identifiers will be readable, writable or executable in your WebUI app. For all details on what is possible, please refer to the documentation.

Work on WebUI Robustness

Under the hood, we have done a lot of work on the WebUI code in this version. This should help us in our goal to make the WebUI more robust. Functionally, there should not be any difference. In terms of performance you may experience a slight gain in specific scenarios.

AIMMS 4.62 Release

Here you can read about the new features introduced in AIMMS 4.62. More details can be found in the release notes. AIMMS 4.62 can be downloaded here.

Features introduced in AIMMS 4.62 (January 2019)

HTML Tooltips for WebUI Scalar and Table Widgets

The Scalar widget and the Table widget now support custom HTML tooltips. The user can override the default tooltip on these widgets using a ‘_Tooltips’ suffix on identifiers, as usual. This gives you a lot of creative freedom to present your tooltips exactly as you want. For example, HTML-tables could be included or even images to pass context-sensitive information to your users.

Better Visual Support for Dragging in WebUI Gantt Chart Widget

The Gantt chart now has support lines/backdrop or indicators when a job is being dragged or resized. This will be a default feature for the Gantt chart. When you drag or resize a job, there will be a background that helps the user drag the job with reference to other jobs. This makes it easier for the user to either line up jobs from different tasks/resources, or schedule jobs one after the other.

The Gantt chart now offers an indication using Today and Now lines, that helps the user identify the exact day and time on the Gantt chart. In combination with the previous feature, this really enhances the usability of the Gantt chart widget.

Expanding Indices in WebUI

In addition to the identifier slicing that is common through all of AIMMS and the WebUI, you can now also expand indices in the WebUI. So, in addition to slicing an index to (for example) a subset, you can now also expand it to a SUPERset. This allows you to match indexes of different identifiers displayed in the same widget. For example, you can make the displaying of related identifiers in a Table much more concise and intuitive. For details and examples, please refer to the documentation.

AIMMS 4.61 Release

Here you can read about the new features introduced in AIMMS 4.61. More details can be found in the release notes. AIMMS 4.61 can be downloaded here.

Features introduced in AIMMS 4.61 (November 2018)

Major Overhaul of the Map widget

The Map widget has undergone a major overhaul. Now it is possible to use multiple arc sets and multiple node sets, you can hide the labels on the arcs or display the arcs as straight lines instead of curved ones. When creating a new map widget, you will automatically get the new version. Existing Map widgets in your apps will remain the old style. In order to use the new functionality, you should redo the existing maps. For details on how to set up a new Map widget and all the possibilities with it, please refer to the documentation.

AIMMS 4.60 Release

Here you can read about the new features introduced in AIMMS 4.60. More details can be found in the release notes. AIMMS 4.60 can be downloaded here.

Features introduced in AIMMS 4.60 (October 2018)

Find All and Bookmark Functionality in AIMMS IDE

The AIMMS IDE has been extended with Find All functionality and with a mechanism to set bookmarks.

With the Find All button/menu item, you can enter a search term, for which AIMMS will list all occurrences. The difference with the existing Find functionality is, that the latter only allows you to move from one found occurrence to the next, without keeping the total overview. There are two possible output windows into which you can send the Find All results and it is possible to limit the number of occurrences displayed.

Using the Bookmark mechanism, it is possible to mark specific lines in your code for later reference. You can also define categories for your bookmarks. This allows you to quickly move to important parts of your model during development. The bookmarks/categories are being saved with your model, such that you can refer to them at a later stage as well. Of course you can delete them too if you do not need them anymore.

Store Focus In Bar Chart and Line Chart Widgets

The Bar Chart and the Line Chart widgets now also support Store Focus functionality, allowing you to associate element parameters with the bar/dot that the user currently selects. This provides flexibility in presenting master/detail views of your data.

Improved Gantt Chart Hovering

When hovering over or selecting a job in a Gantt Chart widget, now the selected job is made more prominent by desaturating the other jobs and by lowering their opacity.

AIMMS Email Client Library

AIMMS has been extended with a library which you can use to send email directly from your AIMMS application. This way, you can for example send the results of your optimization model to other users in your organization. The library consists of a number of functions that you can use to set up your email message, to add attachments to it if needed, and to send it. For details on the functions contained in the library and an example, please see the documentation.

The AIMMS Email Client Library is available from the AIMMS Library Repository within the Library Manager in the AIMMS IDE.

AIMMS 4.59 Release

Here you can read about the new features introduced in AIMMS 4.59. More details can be found in the release notes. AIMMS 4.59 can be downloaded here.

Features introduced in AIMMS 4.59 (September 2018)

New WebUI Look and Feel

We are introducing a new default theme in AIMMS WebUI as we felt the current default was not up to par and typically needed rework while we prefer to give you an out of the box great experience. The new default Theme is part of the UX 2.0 project referred to before, and should allow you to build nice looking Apps from the moment you start. Together with the new Action Menu as well as the new Navigation on top of each App, it also provides you with a clear and uniform look and feel, and help users work more naturally through Apps and have the ability to focus on what is important.

Of course there are still ways to tune this style, but we certainly hope that is limited to a few small things. We are making a some options directly available for you such as: adding an App Icon (or company logo), changing the color of the separation line between Navigation and page (e.g. in your core house style color), and possibly even the background color of the main screen. We suggest to leave other items alone as much as possible as that assures better upgrade compatibility when changes in the technology and style occur.

Also, we are not done yet. The focus of our current theme has been on the general look-and-feel, improving the settings and manager panels a next step will be to look at the coloring inside the widgets. So please stay tuned and we are looking forward to improving AIMMS step by step so you can work with more joy and ease towards bringing value to end users.

We recognize that some of our customers created full or partial custom themes via Application Specific Resources and we have therefore added the options to keep these projects run in the ‘Classic Theme’ by an application setting. If you are ready to upgrade, you can set the switch to the new theme and see how it works for your customization (and you will notice you have to make some adaptions). You can also decide to remove all your customization and start from scratch using our new default theme. In any case, we love to hear from you if you do be sure to ask for support as these things will take some time. New Apps will start with the new theme from scratch as the default (and only) option.

New Bar Chart and Line Chart Options

The Barchart and the Linechart widget now offer the possibility to specify a minimum bound, a maximum bound and the step size for the Y-axis. This allows you to provide the end-user of your WebUI apps with more focus on specific parts of your data.

Improved Chart Hovering and Select

When hovering over elements in the chart widgets in the WebUI, the hovered over item in a Bar, Line, Pie and Treemap chart is now displayed more prominently (other elements get lighter) such that you can better understand what you are looking at. In addition, you can also select the specific element and all other items fade even more to the background (see picture below). The latter is a precursor to having store focus support in all chart widgets.

AIMMS 4.58 Release

Here you can read about the new features introduced in AIMMS 4.58. More details can be found in the release notes. AIMMS 4.58 can be downloaded here.

Features introduced in AIMMS 4.58 (August 2018)

Text in Gantt chart bars

The Gantt chart widget in the AIMMS WebUI has been extended with the possibility to show text inside the associated bars. The text can be used to display additional information for each bar, allowing the user to have a direct overview of the data that they need. To show text in the bars, the app developer needs to add an _text annotation identifier with the same index domain as the duration identifier. The data of the new identifier will then be displayed in the bars. For more details, please read our documentation on the Gantt Chart.

More Clear Layout of Table Sorting

In previous versions of AIMMS, it was hard to see how or whether Table widgets were sorted. From AIMMS 4.58 onwards, this has changed. If a column or a row is sorted, this is now clearly visible by a sorting indicator. Also, there is a new and clear dialog from which to set your sorting.

AIMMS 4.57 Release

Here you can read about the new features introduced in AIMMS 4.57. More details can be found in the release notes. AIMMS 4.57 can be downloaded here.

Features introduced in AIMMS 4.57 (July 2018)

Full Control Over Integer Sets

For each subset of Integers you can now specify either of the two properties ‘ElementsAreNumerical’ or ‘ElementsAreLabels’ to have full control on how elements of these sets behave in an expression. See the Language Reference or our tech blog for more information on this.

Extra Arguments for UponChange Procedures

The UponChange procedures for the WebUI have been extended with 2 arguments. Until now, the mechanism basically just told you that a specific identifier had changed, but there was no information available about which specific tuples had changed or what the old values were. Now this information is available for you.

Delete and Backspace in the Table widget

The delete and backspace keys can now be used in the Table widget to quickly delete the present value (the delete key), or to delete it and immediately open the cell editor (the backspace key).

HTML in WebUI Tooltips

The _Tooltips identifier that you can use to override the default tooltip of the WebUI widgets now accepts HTML formatting as well.

AIMMS 4.56 Release

Here you can read about the new features introduced in AIMMS 4.56. More details can be found in the release notes. AIMMS 4.56 can be downloaded here.

Features introduced in AIMMS 4.56 (July 2018)

WebUI Health Check

The WebUI now has a ‘health check’ facility. Should you run into a ‘Data Session Lost’ situation in your app, the WebUI will, after a few seconds, automatically perform some connectivity checks. When this is done, it offers you the possibility to download a small report to your local machine. If the problem persists, you can provide this report to AIMMS support for analysis, which will provide us with more insight into the problem.

WebUI Identifier Headers

The identifier columns/rows in the Table widget now display the set name(s) of the identifier(s) which are in the table. This makes it easier to understand what the tuples are about. Please be aware that this does not work yet for sets which are defined in libraries.

AIMMS 4.54 Release

Here you can read about the new features introduced in AIMMS 4.54. More details can be found in the release notes. AIMMS 4.54 can be downloaded here.

Features introduced in AIMMS 4.54 (June 2018)

Fast Editing in the WebUI Table Widget

Up until AIMMS 4.54, editing values in the WebUI Table Widget could be a slow process. With this new release, this has been made very fast, allowing you to do your data editing work more efficiently.

AIMMS 4.53 Release

Here you can read about the new features introduced in AIMMS 4.53. More details can be found in the release notes. AIMMS 4.53 can be downloaded here.

Features introduced in AIMMS 4.53 (April 2018)

New WebUI Page Navigation Menu

Introduction This year, we started a new user experience improvement project called UX 2.0 to drastically improve the usability of AIMMS applications. To get to the right design and user experience, we uphold 3 key principles:

  • We want to Democratize Prescriptive Analytics, making it easier to onboard new users
  • We want to Reduce Time-To-Value, the ability to gain faster and better insights
  • We want to Tame the Chaos, a clear and focused experience in all Apps

One such improvement is our roll out of a new Navigation Menu. This menu should help users find their way around AIMMS Apps and get a general overview much more easily. As this new menu will become the new default, your existing Apps will change automatically.

The menu supports up to a maximum of six columns on one row (width 1024). AIMMS recommends using no more than that, but the menu does support it if needed by introducing a second row even adding a 7th column if possible due to wider screen usage. The menu supports up to 10 menu items and five levels of hierarchy. However, AIMMS recommends using no more than three giving you a theoretical 600 pages (6x10x10). If more are needed it could be wise to reconsider the app architecture.

AIMMS CDM (Collaborative Data Management)

AIMMS has been designed to allow AIMMS modelers to create decision-support Apps for their end-users. Prescriptive decision-support apps implemented with AIMMS typically recommend one or more possible courses of action. Being able to play with the input data of the model and observe the consequences on the actions suggested by the model, is essential for the end-users to gain confidence in the solution(s) presented. Because user changes can occur throughout the App before being committed, creating multi-user Apps with the current database and case functionality in AIMMS is very tough to accomplish.

CDM implements version control on AIMMS model data, very similar to the functionality offered by modern version control systems such as git. It offers a version control repository for AIMMS data within a regular relational database, with all data being stored in a tree of branches (or revision sequences). This allows you to effectively collaborate with other users and review each other’s changes. CDM enables you to:

  • Check out the data snapshot in a particular revision
  • Commit, pull, revert, and select change sets
  • Create and merge branches
  • Resolve merge conflicts

On top of that, CDM offers the capability to automatically commit and pull changes. All of these functionalities combined, allow AIMMS modelers to create versatile multi-user work flows for decision-support apps that are suitable for a range of use cases:

  • For operational decision support apps operating on a single data set, CDM supports a concurrent editing work flow, where end-users will be able to view other users’ changes as soon as they are committed.
  • For tactical and strategic apps, end-users can work independently on one or more scenarios, represented as branches in the CDM repository.

CDM is available from the AIMMS Library Repository within the Library Manager in the AIMMS IDE. Read more in our CDM documentation and in this sample implementation project.

AIMMS 4.50 Release

Here you can read about the new features introduced in AIMMS 4.50. More details can be found in the release notes. AIMMS 4.50 can be downloaded here.

Features introduced in AIMMS 4.50 (February 2017)

New Method for Annotations in WebUI

To add annotations to your WebUI, it is no longer needed to create an ‘_annotations’ suffix to the relevant model identifiers. Instead, you can use the annotations attribute of them now and specify a ‘webui::AnnotationsIdentifier’ annotations attribute. An advantage of this new method is that if you rename the original identifier, you do not run into the problem that the _annotations identifier is not renamed accordingly. Of course, it is also much ‘cleaner’ to not rely on naming of your identifiers in order to trigger specific functionality. For more details, see this page in the WebUI manual. This also means that you can now annotate the nodes in your Map widgets, by specifying an annotation on the set that defines the nodes.

Dynamic Arc Widths in the WebUI Map Widget

The arcs in a WebUI Map widget can now dynamically show the relative sizes of the flows they represent by drawing the arcs thinner or fatter. By default, this option is turned off, in order to have backward compatibility in your apps. In the Miscellaneous tab of the Map options editor, you can switch it on.

Reverse Link Support in the WebUI Map Widget

Like a number of other widgets, the WebUI Map widget now also supports reverse links. This means that if you click on a node somewhere in your map, you can automatically fill an element parameter which then holds the element corresponding to the selected node. This allows for all kinds of interactivity in your app.

AIMMS 4.47 Release

Here you can read about the new features introduced in AIMMS 4.47. More details can be found in the release notes. AIMMS 4.47 can be downloaded here.

Features introduced in AIMMS 4.47 (January 2017)

CPLEX 12.8 has been added to AIMMS. It comes with performance improvements for MIP problems.

More Clear End-User Options Editors

The options editors are now more limited to PRO users of your WebUI apps. This means that they only see/can change the relevant options for widgets in PRO mode, or the options editors will not show at all if no relevant options can be set by the end-user.

AIMMS 4.46 Release

Here you can read about the new features introduced in AIMMS 4.46. More details can be found in the release notes. AIMMS 4.46 can be downloaded here.

Features introduced in AIMMS 4.46 (December 2017)

New ODH-CPLEX Solver

AIMMS now offers ODH-CPLEX, which is a new solver designed to run on modern multiprocessor machines. Many cores are exploited by the ODH-CPLEX engine by breaking complex models and difficult MIPs into sub-models and solving them into parallel threads. ODH-CPLEX combines this new algorithm with CPLEX specifically to find solutions for difficult and/or massive MIP models. ODH-CPLEX is designed for scheduling problems but works for any MIP which has a reasonable number of integer feasible solutions. It has been deployed effectively on packing problems, supply chain and telecoms as well as scheduling applications. On large scale MIPs it provides good solutions and optimality measures that are often beyond the reach of traditional optimization methods.

CONPOPT 4.0 has been added to AIMMS. It comes with performance improvements for large nonlinear models. CONOPT 4.0 is less likely to end up in a locally infeasible solution.

New Element Text Mechanism

We introduced a new, more elegant, way to add element text to your WebUI. This used to be done by specifying a .js file. Now it’s done from within the AIMMS model and it allows you to replace element names with any alternative text that you like. Furthermore, it includes an inheritance mechanism between sets and subsets, for even more flexibility.

Page Jumps Using WebUI Button

The WebUI Button widget can now, apart from executing procedures, also be used to jump to another WebUI page or to an external web page.

Hiding Options From End-Users in WebUI

Using the UI Editable application option now disallows end-users to open the options editors of the widgets in your WebUI app. Furthermore, on touch devices, it is now also possible to hide the options editors for your end-users.

AIMMS 4.45 Release

Here you can read about the new features introduced in AIMMS 4.45. More details can be found in the release notes. AIMMS 4.45 can be downloaded here.

Features introduced in AIMMS 4.45 (November 2017)

No Restart Needed Upon Adding New Identifiers

Until now, when not explicitly using the AllPublicIdentifiers set, you had to restart your AIMMS model every time you added a new identifier which you wanted to use in your WebUI, slowing down your development process. From this version onwards, when developing your WebUI, all accessible identifiers are immediately selectable in the WebUI, even if they are not part of the AllPublicIdentifiers set. When running the resulting WebUI on PRO, however, the AllPublicIdentifiers set is still respected when the end-user tries to change the content of a widget, thus keeping the protection advantage of using this set.

Page Manager Available for End-Users

The Page Manager is now also available when running your WebUI app on PRO. With it, end-users of your WebUI apps can more easily navigate the pages in their app and get an overview of the current page tree. The existing horizontal page menu can also still be used. There are new project options to specify which of these you want to offer to your end-users. It is also possible to use both at the same time, or to make sure that the Page Manager is already open upon starting up your WebUI.

Library Repository

A library repository browser is added to the Library Manager that will allow AIMMS to make extra libraries available that can easily be included in projects. Note that libraries with a version number starting with 0 are for internal testing and should not be used it in any serious project.

AIMMS Datalink Library

The AIMMS DataLink library was added. This is a library that allows different types of data sources to read and write data from and into AIMMS, using a common interface. For more information, please see the documentation.

AIMMS 4.44 Release

Here you can read about the new features introduced in AIMMS 4.44. More details can be found in the release notes. AIMMS 4.44 can be downloaded here.

Features introduced in AIMMS 4.44 (October 2017)

Adjustable Node Sizes in Map Widget

From this version onwards, you can add an extra 1-dimensional parameter to the Contents of your Map widget. In this parameter, you specify the size for each node on the map. The bigger the size, the bigger the resulting blue disc on the node (though there is a maximum node size). It is also possible to use negative node sizes, for example to provide profit/loss info per node these are rendered in red.

AIMMS 4.40 Release

Here you can read about the new features introduced in AIMMS 4.40. More details can be found in the release notes. AIMMS 4.40 can be downloaded here.

Features introduced in AIMMS 4.40 (September 2017)

New Page Manager

We have created a new Page Manager, that will allow you to better manage your WebUI Page Tree. This new Page Manager allows you to easily add, rename, restructure and delete pages. Furthermore, you can let AIMMS identifiers specify the visibility of a page for your end-users. For details, please read our manual. To be able to use AIMMS 4.40, your project needs to be converted such that the new Page Manager can be used. Please create a backup of your project before you convert it. After conversion, your project is no longer compatible with older AIMMS versions! Please note that you will get a warning before your project is converted.

After conversion of your project, a Page Menu will be displayed in your project. The Page Menu is based on all the pages in your Page Manager and uses the same tree structure. The visibility of a page determines whether the page shows up in the menu or not. By using AIMMS identifiers for the visibility, you can dynamically change the Page Menu. For details, please read our manual.

In the new Page Manager, you can also create so-called Wizards. A Wizard is a series of pages that a user should follow in a certain order. In the Wizard Editor, you can indicate which pages belong to the wizard and in which order they should be visited. Furthermore, next to the Page Procedure that every page can have, you can specify a start and end procedure for each page in the wizard. You can select these procedures in the Wizard Editor that is accessible from within the Page Manager. It allows you to e.g. disallow a user to go to the next page when the user has not yet filled in all the required data. For details, please read our manual.

Multi-line Scalar Support

The Scalar Widget has been extended with an option called ‘Enable Multi-Line’. When set to 1, string values are displayed in multi-line mode, allowing the user to enter long strings, like e.g. a description. For details, please read our manual.

WebUI Startup

When creating a new WebUI project, the PRO and WebUI libraries are now automatically added to your project. The default UI will be WebUI, unless you choose for WinUI. If you still want to use WinUI pages, you should set the DefaultUI option to WinUI and you can still use WebUI next to WinUI. Furthermore, your WebUI home page in the browser is now accessible more easily, as we have added a WebUI menu to the AIMMS toolbar and extended the Tools – WebUI menu with all the supported browsers.

AIMMS 4.38 Release

Here you can read about the new features introduced in AIMMS 4.38. More details can be found in the release notes. AIMMS 4.38 can be downloaded here.

Features introduced in AIMMS 4.38 (July 2017)

Slider Widget in WebUI

The set of widget types in the AIMMS WebUI has been extended with the Slider widget. With this Slider widget, you can change the value of a scalar identifier by dragging a slider handle to the left or right. You can specify a min, max and step size value for this widget type. For details, please read our manual.

AIMMS 4.37 Release

Here you can read about the new features introduced in AIMMS 4.37. More details can be found in the release notes. AIMMS 4.37 can be downloaded here.

Features introduced in AIMMS 4.37 (June 2017)

Slicing Data in WebUI Widgets

The Identifier Settings tab that can be found in most of the WebUI widget option editors, has been extended with a Slicing feature. On this tab, you can specify whether you want to slice the data that is displayed in the widget. Per identifier, you can slice one or more dimensions (indices) to either a subset, an element parameter value, or a fixed element. This allows you to easily show part of your data in a widget. E.g. you could create a selection-box that displays an element parameter and a table that shows data that is sliced to that element parameter. For details, please read our manual.

AIMMS 4.36 Release

Here you can read about the new features introduced in AIMMS 4.36. More details can be found in the release notes. AIMMS 4.36 can be downloaded here.

Features introduced in AIMMS 4.36 (June 2017)

Keyboard Navigation in WebUI Table widget

The Table widget now offers the possibility to navigate it with the keyboard too. There is always a cell which has the focus in a table. You can use the arrow keys to navigate this focus cell around. You can start editing ‘normal’ cells immediately, by starting to type. Dropdown cells can be opened by either pressing [ENTER] or [ALT-ARROW DOWN]. Checkboxes can be set to their two values by typing 𔃰’, 𔃱’, or [SPACE] to toggle the present value.

‘Reverse Link’ Functionality Available in WebUI Table Widget

The Table widget now has the ‘Reverse Link’ functionality in place (as you may know from the WinUI). With this, you can specify which element parameters should be updated automatically when the focus cell of the Table widget changes (it does not work the other way around, though). It can be set on the ‘Store Focus’ tab on the Table widget options editor.

Some Background on Possible Differences in Errors and Warnings

Since the second half of 2016, we started a process in which the compiler of AIMMS, that is responsible for compiling all the identifier attributes, is gradually being replaced by a completely new implementation that is better prepared for the (also new) execution engine that is capable of running expressions in parallel using multiple threads. We try to keep this replacement as smooth as possible, such that the developer hardly notices that things have been changed. However, in one specific area the differences are noticeable and that is in the warning and error messages that are generated. The possible differences are:

    • The text of the error or warning messages is different
    • The handling of warnings might be handled by other options (example ‘warning_explicit_element_not_in_set’) and
    • The new compiler might be more strict on the syntax as it is defined in the Language Reference.

    It will take some time before the new compiler and new engine can handle all the expressions and constructs that are allowed in AIMMS. During this transition period you can get warnings and errors from either of the two implementations.

    AIMMS 4.34 Release

    Here you can read about the new feature introduced in AIMMS 4.34. More details can be found in the release notes. AIMMS 4.34 can be downloaded here.

    Feature introduced in AIMMS 4.34 (April 2017)

    ‘Snappy’ Table Widget Editing in WebUI

    In the Table Widget in the WebUI, it did not always feel very fast to edit data values, especially not when having other widgets on the same page, which displayed the same identifier(s) as displayed in the Table widget. Now, by introducing a new internal buffering algorithm, editing data in the Table feels very ‘snappy’.

    AIMMS 4.33 Release

    In the AIMMS 4.33 release, no new features have been introduced. There was a technical reason to increase the version number instead.

    AIMMS 4.32 Release

    Here you can read about the new features in AIMMS 4.32. More details can be found in the release notes. AIMMS 4.32 can be downloaded here.

    Features introduced in AIMMS 4.32 (February 2017)

    Control Over Data Density in WebUI Widgets

    In the WebUI, there is a new option for all widgets, with which you can control the sparsity domain of the identfier(s) displayed in the widgets. This means that you now have full control over which values will be displayed or hidden in your widgets. You can use this, for example, to force the displaying of rows/columns in a Table which only contain default values. You can also use it to display slices of your data, or to filter your data. The option which controls this behaviour is called ‘Display Domain’. It can be found on the new ‘Identifier Settings’ options dialog in the widget options editor (see screenshot below). For details on how to use this feature, please see the documentation.

    AIMMS 4.31 Release

    Here you can read about the new features in AIMMS 4.31. More details can be found in the release notes. AIMMS 4.31 can be downloaded here.

    Features introduced in AIMMS 4.31 (January 2017)

    WebUI Support For IE11/Edge Browsers in Beta

    Good news for users who cannot use Google Chrome on their system: both Internet Explorer 11 and Microsoft Edge can now be used with the WebUI. Please note that we are still in the beta phase. So, if you find anything not working as expected, please let us know. Furthermore, Google Chrome remains the preferred browser for the AIMMS WebUI, as it performs better than either IE11 or Edge.

    CP Optimizer 12.7

    CP Optimizer 12.7 has been added, offering significant performance improvements for scheduling problems. Note: CP Optimizer 12.7 is not available for 32 bits Windows.

    AIMMS 4.30 Release

    Here you can read about the new features in AIMMS 4.30. More details can be found in the release notes. AIMMS 4.30 can be downloaded here.

    Feature introduced in AIMMS 4.30 (December 2016)

    CPLEX Upgraded to Version 12.7

    CPLEX 12.7 is now available. CPLEX 12.7 comes with significant performance improvements for MIP, MIQP, MIQCP, and nonconvex QP and MIQP models. CPLEX 12.7 features a Benders decomposition algorithm which can be used to solve linear problems with a decomposable structure, including stochastic programming problems with integer variables in the first stage. For more information, see the new option ‘Benders strategy’. CPLEX 12.7 also offers modeling assistance in the form of warnings regarding performance degradation or numerical stability this is controlled by the option ‘Data check and modeling assistance’. Note: CPLEX 12.7 is not available for 32 bits Windows.

    AIMMS 4.29 Release

    Here you can read about the new features in AIMMS 4.29. More details can be found in the release notes. AIMMS 4.29 can be downloaded here.

    Features introduced in AIMMS 4.29 (November 2016)

    Column Width Dragging in WebUI

    In the Table Widget in the WebUI, it is now possible to resize the columns and the row area by just using the drag handles that appear when you hover over the border between two columns. This allows more flexibility in the way you present your table data to your end-users.

    AIMMS 4.28 Release

    Here you can read about the new features in AIMMS 4.28. More details can be found in the release notes. AIMMS 4.28 can be downloaded here.

    Features introduced in AIMMS 4.28 (November 2016)

    Improvements in Advanced Methods for Nonlinear Programs

    We have made improvements in some advanced methods for nonlinear programs. The multistart algorithm has been improved such that it finds good solutions for a wider range of nonlinear models. A detailed description of the new algorithm can be found in the Language Reference. Furthermore, the AIMMS Presolver can now automatically scale a model, and use optimization-based bound tightening to tighten the variable bounds even further.

    Faster Editing in WebUI Table Widget

    The responsiveness of the WebUI Table widget when editing data values has been improved significantly.

    AIMMS 4.27 Release

    Here you can read about the new features in AIMMS 4.27. More details can be found in the release notes. AIMMS 4.27 can be downloaded here.

    Features introduced in AIMMS 4.27 (October 2016)

    Faster Opening of WebUI Pages

    WebUI pages will load faster on average, when switching pages in your application. From this version on, the data structures underlying the web pages that you have already closed are marked as inactive, 30 seconds after closing. That means that when you open a new page, which usually causes the underlying data structures to be updated, these inactive data structures do not have to be updated anymore, which results in a quicker loading time of your newly opened page. This effect is most prominent in applications which use several pages with big AIMMS identifiers. Of course, when the inactive data structures are needed again, they are made active again automatically and updated when needed.

    AIMMS 4.26 Release

    Here you can read about the new features in AIMMS 4.26. More details can be found in the release notes. AIMMS 4.26 can be downloaded here.

    Features introduced in AIMMS 4.26 (October 2016)

    Reverse Link support for Bubble Chart widgets in WebUI

    The Bubble Chart widget now also offers reverse link functionality. You can specify element parameters which should be filled based upon the currently selected bubble in the chart.. For details on how to use it, see the Bubble Chart documentation.

    Extended the AIMMS Excel Library

    The AimmsXLLibrary has been updated to include table write functionality and a number of methods to create new workbooks and sheets. The documentation of the AIMMS Excel Library is in the library itself: each function/procedure is documented in its comment field.

    AIMMS 4.25 Release

    Here you can read about the new features in AIMMS 4.25. More details can be found in the release notes. AIMMS 4.25 can be downloaded here.

    Features introduced in AIMMS 4.25 (September 2016)

    New Bubble Chart Widget in WebUI

    We have introduced a new widget type in the WebUI: the Bubble Chart. With this chart, you can display up to 3 aspects of your data at once. In a X/Y plane, circles (called ‘bubbles’) are displayed, where the size of the bubbles also depict an aspect of your data. For details on how to use it, see the Bubble Chart documentation.

    Override the Default Tooltips in WebUI

    It is now possible to override the default tooltips of all widgets in the WebUI with your custom strings, allowing you to fine-tune how your users will see the details of the data that you have displayed. To learn how to do this, please see the documentation.

    AIMMS 4.24 Release

    Here you can read about the new feature in AIMMS 4.24. More details can be found in the release notes. AIMMS 4.24 can be downloaded here.

    Features introduced in AIMMS 4.24 (August 2016)

    More Stable and Faster Table Widget in WebUI

    In this version of AIMMS, the Table widget in the WebUI has been replaced with a new implementation, which offers more stability and faster operation, even with large datasets. All tables in your WebUI are automatically updated to the new one if you run AIMMS 4.24. However, should you have reasons for keeping the old table, you should use the previous version of AIMMS for that.

    Reverse Link Support and Viewport Options in Gantt Chart Widget

    The Gantt Chart now supports reverse links (using the Store Focus tab in its options editor) and has new options to specify the visible viewport, allowing to implement scrolling/zooming in your model. For details, see the Gantt Chart documentation.

    AIMMS 4.22 Release

    Here you can read about the new feature in AIMMS 4.22. More details can be found in the release notes. AIMMS 4.22 can be downloaded here.

    Features introduced in AIMMS 4.22 (July 2016)

    A Flexible Way of Locking a WebUI

    Previously, if you wanted to make sure that the AIMMS PRO users of your WebUI would not change the user interface (by resizing widgets, for example, or by switching widget types), you had to define a special PRO users group, which you had to give a certain pre-defined and hardcoded name. In this AIMMS 4.22 version, this is implemented differently and in a far more flexible way: there is an application options dialog, where you can set the new option called “UI Editable”. The default value is true (or 1), meaning that every user is able to change the UI to his/her liking. If you want to change that, you can set the option to false (or 0). The best thing about this, is that you can also specify an AIMMS identifier as the value for this option. This way, you can use any kind of model logic to determine which users are allowed or forbidden to change the UI.

    AIMMS 4.21 Release

    Here you can read about the new features in AIMMS 4.21. More details can be found in the release notes. AIMMS 4.21 can be downloaded here.

    Features introduced in AIMMS 4.21 (June 2016)

    Time Window and Vertical Drag and Drop in WebUI Gantt Chart Widget

    Previously, the WebUI’s Gantt Chart widget’s time window was defined by the activities displayed in the chart: the left border of the Gantt Chart was determined by the earliest activity, and the right border was determined by the last activity. As a user, you want to have more control over which part of the data is displayed. For example, if you display a Gantt Chart which covers 2 years of planning data, you may be interested in just the first 3 weeks. This new feature lets you specify the begin date and the end date of this so-called ‘viewport’. These dates determine what part of the Gantt Chart is actually displayed. Since these two values can be specified using AIMMS model identifiers too, they can be used to implement advanced scrolling and/or zooming functionality by the model developer. For more details, see the Documentation on the Gantt Chart.

    Fast Version of the WebUI Table Widget

    The current Table widget of the WebUI does its job, but in situations that you need to display a huge amount of data, its performance in terms of speed is not always fully up to the task. In this release, we offer a partial rewrite of the Table widget, called the New Table widget. This New Table widget offers a far better performance than the old one, including smooth scrolling in both directions and sorting. In the current iteration of the widget, it’s still a read-only version though. We are working on getting the New Table to support all the functionality of the existing Table widget (including full editing possibilities). For now, if you only want to display your data (i.e. don’t want users to edit the data), you can simply switch to the New Table widget type from any already existing Table widget (just do a type switch through the options editor).

    AIMMS 4.20 Release

    Here you can read about the new features in AIMMS 4.20. More details can be found in the release notes. AIMMS 4.20 can be downloaded here.

    Features introduced in AIMMS 4.20 (May 2016)

    AIMMS Excel Functions Usable in Server Environments

    The existing AIMMS Excel functions had the important restriction that the environment on which the AIMMS model was executed must have Excel installed. In server environments, such as running your model through a WebUI on PRO, this was a problem. In AIMMS 4.20, the most commonly used Excel functions have been rewritten to use a new library, which doesn’t need Excel to be installed in order to work. This also means that you can use the Excel functions in the Linux version of AIMMS. In order to use the functions, please add the system library ‘AIMMSXLLibrary’ to your model. The functions are documented in the library itself.

    Greatly Improved Usability of the WebUI Gantt Chart

    The WebUI Gantt Chart has been hauled over quite a bit in AIMMS 4.20. New features include horizontal drag and drop functionality, clear and unambiguous rendering of (partly) overlapping bars, more sensible X-axis labels, detailed tooltips when hovering over the bars and alternating background colors. For more details, see the updated documentation on the Gantt Chart.

    AIMMS 4.19 Release

    Here you can read about the new features in AIMMS 4.19. More details can be found in the release notes. AIMMS 4.19 can be downloaded here.

    Features introduced in AIMMS 4.19 (March 2016)

    Download Widget

    In the WebUI, we have added a new widget: the Download Widget. With this new widget, you can run an AIMMS procedure that prepares/creates a file to be downloaded by the app user, after which the in-browser download functionality allows the app user to download the just created file.

    New Online Manuals PRO/WebUI

    The manuals for AIMMS WebUI and AIMMS PRO have been improved, re-structured and made up-to-date. You can find them here:

    AIMMS 4.18 Release

    Here you can read about the new features in AIMMS 4.18. More details can be found in the release notes . AIMMS 4.18 can be downloaded here.

    Features introduced in AIMMS 4.18 (March 2016)

    Dropdown Box with Search Functionality

    In the WebUI, we have added a new implementation of the dropdown box, which is visible in the scalar and the table widget types if an element parameter is displayed. This new implementation adds a search box, which greatly helps you if the range of the element parameter is a big set. You can simply type any (sub)string: the search box will provide you with all the set elements that match your search. Furthermore, you can use some basic regular expressions in the search box, giving you even more flexibility when searching. For more details on the more common possibilities that regular expressions offer, see the documentation.

    DatePicker Widget Deprecated, But…

    In the WebUI, the DatePicker widget has been deprecated. But: in case you need this functionality, you can now use the new dropdown box, introduced above, giving you even more flexibility than before! If you let it show an element parameter defined over an AIMMS calendar, you can still pick dates. For example: if you use a date format showing the weekdays, you can search for ‘Mon’ to quickly get an overview of all Mondays. Or you can type ‘2016’, to get all available dates in 2016. Using the ‘.*’ sign, you can even combine both by using a regular expression: searching for ‘Mon.*2016′ will show you all Mondays in 2016, for example.

    AIMMS 4.17 Release

    Here you can read about the new features in AIMMS 4.17. More details can be found in the release notes. AIMMS 4.17 can be downloaded here.

    Features introduced in AIMMS 4.17 (March 2016)

    Performance improvements selection widgets

    We have made some changes that improve the performance of the selection widgets. Furthermore, you can now select several items in a row without having to scroll up all the time.

    Search box in Selection-Box

    The Selection-Box widget will now also display a Search Box. It appear as soon as you click on the Selection-Box.

    AIMMS 4.16 Release

    Here you can read about the new features in AIMMS 4.16. More details can be found in the release notes. AIMMS 4.16 can be downloaded here.

    Features introduced in AIMMS 4.16 (February 2016)

    Upload Widget in the WebUI

    We have created a new widget type for you: the Upload Widget. With this widget, end-users can upload a file to the AIMMS PRO server, which can then be further processed by the AIMMS model. This is very useful for Web Apps that depend on user specific data that is not yet available on the server (e.g. Excel data input).

    The Upload Widget has, like the Button Widget, a call ‘Procedure’ option, in which you can specify the AIMMS procedure that will run once the upload is finished. Please read the documentation for more details.

    Mouse/Touch Support in the WebUI

    If you use the AIMMS WebUI on a Windows device with a touch screen (such as a Microsoft Surface tablet), the WebUI will show an additional button that allows you to toggle between touch-input and mouse-input.

    The WebUI will automatically detect touch support and implement improvements for touch interaction. These improvements impair some mouse interactions. If you use the AIMMS WebUI primarily with a mouse, we recommend that you toggle to mouse-support. This setting will be remembered by your browser.

    AIMMS 4.15 Release

    Here you can read about the new features in AIMMS 4.15. More details can be found in the release notes. AIMMS 4.15 can be downloaded here.

    Features introduced in AIMMS 4.15 (February 2016)

    Single Line Option Editor supports AIMMS identifier

    To fully customize your widgets, you can now use the data of AIMMS identifiers to provide your widgets with option values. This allows you to specify the options (at the Miscellaneous tab in the option editor) in a more dynamic way. You can let your model decide on the value of e.g. the new ‘Visible’ option.

    Specifying an AIMMS identifier for the ‘Visible’ option

    Hiding Specific Widgets using the ‘Visible’ Option

    With the ‘Visible’ option, your app users will be able to focus more on the information that is relevant to them. As an app developer, you can now control for each widget whether it should be visible for a specific app user. This allows you to create a user interface that is customized for every (group of) user(s). You can find the ‘Visible’ option at the ‘Miscellaneous’ tab of the widget option editor. If you use an AIMMS identifier to determine the visibility of the widget, you can use all AIMMS logic that you need. E.g. only show the widget when relevant for the user (group), or only show a widget when certain data is available. Please read the documentation for more detail.

    Basic Sorting in the Table Widget

    From now on, all WebUI users can do basic sorting in the Table widget. This allows you to get a better insight into your data. You can sort on both rows and columns (one at a time).

    Basic Sorting in the Table Widget

    AIMMS 4.14 Release

    Here you can read about the new features in AIMMS 4.14. More details can be found in the release notes. AIMMS 4.14 can be downloaded here.

    Features introduced in AIMMS 4.14 (January 2016)

    Parallel solving automatically enabled for CPLEX

    The default values of the CPLEX options ‘Parallel mode’ and ‘Global thread limit’ have been changed for CPLEX 12.6 and higher. By default, CPLEX will now use the deterministic mode and all available threads for solving MIP problems, and LP problems if the barrier algorithm is used. This can lead to significant performance improvements when solving MIP or LP problems.

    Improved identifier selection for widgets

    When selecting identifiers to determine the contents of a new widget, or when editing an existing widget, has been improved by offering a more extended wizard. To make selection easier, the wizard now shows the identifier type (set, parameter etc). The limit of the number of identifiers shown, has been dropped (initially the pull-down list will contain the first 100 identifiers and the last item in the list tells you there is more using search you can list and select those). In addition, when creating a new widget, you can directly add multiple identifiers to Current Contents. These new features make life easier for the app developer and for the end user who is changing widget contents.

    ‘No Changes Allowed’ feature for WebUI Apps

    We added a ‘No Changes Allowed’ feature for AIMMS WebUI Apps, preventing the end user from making changes to the setup of widgets or pages (end users can of course still change data). This feature is set through AIMMS PRO roles and thus can be differentiated per user. It allows the publication of Apps where changing those Apps is considered undesirable. For example because by removing or changing information the user could end up taking the wrong decision. Similarly, this also prevents end users from adding any personal widgets in the App. For more information, please read the documentation. If an AIMMS WebUI App is locked for editing, the editors and widget manager won’t allow any changes to be made by the end user. Greyed out and a lock appears.

    View of the editor and widget manager of a locked AIMMS WebUI App

    Improved line up widgets

    We improved the way widgets and items, such as buttons, line up to help achieve higher data densities and make Apps look better.

    Shift-Click in Multi-Select Widget

    You can now use shift-click in the Multi-Select Widget to select a range of elements shown, at once.

    Control save/restore WebUI State

    By default an AIMMS WebUI App will save its user state (i.e. view) upon closing, and restore its state upon starting the App. As a developer, you can now have more control of this behavior, e.g. override it to not save any user state, or only save part of the user state. To do this, you can specify your own control procedures and using the WebUI State Hook element parameters. Please see the WebUI State Hook Declarations section in the WebUI Library for details.

    Download table to .csv file

    The Table widget now offers you the possibility to download its current contents to a .csv file on your local machine. This allows you to e.g. further process your data in Excel. Please read the documentation for more details.

    AIMMS 4.13 Release

    Here you can read about the new features in AIMMS 4.13. More details can be found in the release notes. AIMMS 4.13 and its release notes can be downloaded here.

    Features introduced in AIMMS 4.13 (November 2015)

    Gurobi 6.5 has been added. Gurobi 6.5 comes with significant performance improvements across MIP, LP, SOCP, MIQP and MIQCP problem types. Gurobi 6.5 supports variable hints: if you have a guess at a high quality solution for a MIP model (for example, from solving a related model), the new variable hint feature allows you to pass that guess to Gurobi to help guide the search for a new solution.

    Position of adjustable resize lines stored

    The current position of adjustable resize lines in a page can now be stored in a model parameter. Doing so prevents the positions of the resize lines on a page from being reset upon re-opening the page.

    Database foreign key handling option introduced

    A new option has been introduced, which may improve the performance of database write statements. Previously, the database would always determine whether the tables affected by your write statements had foreign keys involved. In certain cases, this can be a slow operation. With the new option, it’s up to you to decide whether you want this behaviour or not. You should know what you’re doing, though: in case the tables you write to have foreign keys involved, skipping the check means either getting an error message, or even loss of rows in referring tables, depending on the cascade setting of your database.

    WebUI Improvements

    • The search fields in the multiselect and legend widgets and the contents and filter option editors now automatically (dis)appear when there are (few)/many items to select from.
    • The selection-box widget is now the same height as a button, which decreases the amount of space it takes on your screen.
    • When creating a button widget, you will get a suggestion to use a group widget. A group allows you to group multiple buttons together in a consistent layout.

    AIMMS 4.12 Release

    Here you can read about the new features in AIMMS 4.12. More details can be found in the release notes. AIMMS 4.12 and its release notes can be downloaded here.

    Features introduced in AIMMS 4.12 (November 2015)

    Checkboxes in WebUI forms

    The check-box and pull-down list functionality for forms has been added, making them easier to operate when selecting possible values.

    Dense Data Support in Selection Widgets

    We have started to add the ability to view default data by adding ‘dense data support’ to selection widgets. This removes the need for App developers to set non-default values to force data to be shown.

    Template Selector for WebUI Group Widget

    Previously, in AIMMS 4.10, we introduced widget grouping. In the current release we added the ability to change the preferred layout of the group via a template selector. This way you can easily select the best layout for your widgets and your users will be able to receive an improved experience to operate the App.

    Dynamic error messages in WebUI

    When using forms in your App, you can easily provide the App user with feedback on the data that is filled in in the form. The AIMMS WebUI procedure webui::CreateValidationError that is used for this feedback, is now extended with optional arguments such that you can add information based on model identifier data to the error messages. This allows you to provide your App users with the exact information they need.

    AIMMS 4.11 Release

    Here you can read about the new features in AIMMS 4.11. More details can be found in the release notes. AIMMS 4.11 and its release notes can be downloaded here.

    Features introduced in AIMMS 4.11 (November 2015)

    Checkboxes in WebUI

    Scalar and table widgets in the AIMMS WebUI now display checkboxes for binary parameters. In fact, this will be automatically handled for you when the ranges are set as such. Checkboxes are not displayed for form identifiers yet.

    Dropdown list for element parameters in WebUI

    Element parameters that are displayed in a scalar or table widget in the WebUI now have a drop down list from which you can select one of the elements of the corresponding set. Dropdown lists are not displayed for form identifiers yet.

    AIMMS 4.10 Release

    Here you can read about the new features in AIMMS 4.10. More details can be found in the release notes. AIMMS 4.10 and its release notes can be downloaded here.

    Features introduced in AIMMS 4.10 (October 2015)

    Data Forms and Group Widget in WebUI

    We have extended the WebUI functionality to support Data Forms. The use of Data Forms enables end users to modify and validate multiple data points related to a specific item before applying data changes to the master data, assuring better data consistency. In addition, we implemented Widget Grouping to improve the end user’s WebUI experience. This ensures that chosen widgets stay together, regardless of the device or resolution they are being viewed on.

    Configurable Initial Collapsed State of Pivot Table

    In the Pivot Table object of the WindowsUI, the initial state of a Pivot Table can now be set to collapsed or not. This can be specified per index.

    Extension of Forecasting Library

    We have extended the Forecasting Functions library after its initial launch in AIMMS 4.9. The values of steering parameters for exponential smoothing functions (normal, with trend, or with trend and seasonality) can now be computed such that the Mean Squared Error is minimized.

    Support For .aim/.amb Files Dropped in this Version

    From AIMMS 4.10 onwards, we have stopped the support for .aim/.amb files in our AIMMS versions. In practice, this means that if you have projects that contain files in either of these formats (typically projects that started its development in AIMMS 3 or older), you will need an AIMMS 4 version that is released before AIMMS 4.10 (i.e. 4.0 – 4.9) to convert the project for you into .ams files. After that, you can continue working with your project in AIMMS 4.10 and higher. If you have any questions or concerns about this upgrade, please do not hesitate to contact us via [email protected] .

    AIMMS 4.9 Release

    Here you can read about the new features in AIMMS 4.9. More details can be found in the release notes. AIMMS 4.9 and its release notes can be downloaded here.

    Features introduced in AIMMS 4.9 (August 2015)

    Parallel Multistart

    The multistart algorithm has been parallelized as it can now use multiple asynchronous solver sessions to solve an NLP problem, whereby each session uses a different starting point. Using multiple solver sessions might lead to a significant performance improvement. The multiple solver sessions use the same NLP solver. To use this parallel feature, your AIMMS license should allow the NLP solver to use parallel solver sessions.

    Addition of AIMMS Forecasting Functions

    AIMMS 4.9 contains the first version of the ‘AIMMS Forecasting’ library to give app developers who need basic forecasting functionality an alternative to connecting AIMMS to dedicated software such as R or SAS. This first version contains the basic time series forecasting functions for calculating by means of moving average, exponential smoothing, exponential smoothing with trend and exponential smoothing with trend and seasonality. You can find the documentation on these functions in AIMMS: The Function Reference, chapter “Forecasting Functions”.

    WebUI: Support For Project-specific Language Files

    The WebUI now offers support for (multiple) project-specific language files, allowing app developers to add translation tables, for example to show human readable names instead of ‘technical’ identifier names. They can also be used, of course, to show multiple languages.

    Support For .aim/.amb Files Will Stop in the Near Future

    Not really a new feature, but still good to mention here. In the near future (from version 5.0 onwards), we will stop the support for .aim/.amb files in our AIMMS versions. In practice, that means that if you have projects that contains files in either of these formats, you will need an AIMMS 4 version to convert the project for you into .ams files. After that, you can continue working with your project in AIMMS 5. In order to make the transition as smooth as possible for you, AIMMS 4.9 already shows you a warning message every time that you’re using a project that still contains .aim/.amb files in the developer version of AIMMS (i.e. not in the end-user versions).

    AIMMS 4.8 Release

    Here you can read about the new features in AIMMS 4.8. More details can be found in the release notes. AIMMS 4.8 and its release notes can be downloaded here.

    Features introduced in AIMMS 4.8 (July 2015)

    WebUI: Flexible Cell Formatting

    In the WebUI, you can now drive table cell formatting from your AIMMS model. This provides you with very flexible conditional formatting so that you can make your table very easy to interpret for the app users.

    WebUI: Improved Usability of Data Management

    The data management in the WebUI has been improved. It is now more like the way you were used to in AIMMS itself.

    AIMMS 4.7 Release

    Here you can read about the new features in AIMMS 4.7. More details can be found in the release notes. AIMMS 4.7 and its release notes can be downloaded here.

    Features introduced in AIMMS 4.7 (June 2015)

    There is a new version of CPLEX, namely CPLEX 12.6.2. The settings ‘Barrier – Primal crossover’ and ‘Barrier – Dual crossover’ of the option ‘LP method’ have been removed. Crossover is now controlled by the new option ‘Solution type’.

    Sorting of .nch files

    Namechange files (.nch) files are now always sorted consistently. This has the benefit that they don’t show as much ‘changes’ when you compare them with older versions if your project is under a source control system.

    Longer tooltip texts

    Tooltips for page objects can now have any length. Previously, they were cut off at 255 characters.

    Web-based UI case management improved

    Various improvements have been made to the case management of the web-based UI, including shared case management.

    AIMMS 4.6 Release

    Here you can read about the new features in AIMMS 4.6. More details can be found in the release notes. AIMMS 4.6 and its release notes can be downloaded here.

    Features introduced in AIMMS 4.6 (May 2015)

    New AIMMS styling and logo

    AIMMS 4.6 comes in our fresh new styling and with our new logo!

    Progress Time Interval option added

    Progress Window updates are now, by default, based on elapsed time instead of the number of iterations. The new option ‘Progress Time Interval’ controls the progress frequency based on time.

    Web-based UI offers finer grained control over layout

    To improve the flexibility in lay-outing your widgets, the number of columns in the grid that contains the widget has been doubled. As a result, you might have to adjust the width of widgets that have been created with a previous version of the WebUI.

    Web-based UI enables passing of multi-select data to underlying model

    As a first step to make model selections in the WebUI available to the end-user, the multi-select widget now also accepts a one-dimensional parameter (with a default value other than 0 or 1) as its contents. The selected items in the multi-select widget will be kept in sync with the value of the parameter in your model.

    AIMMS 4.5 Release

    Here you can read about the new features in AIMMS 4.5. More details can be found in the release notes. AIMMS 4.5 and its release notes can be downloaded here.

    Features introduced in AIMMS 4.5 (April 2015)

    If you have any questions on these new or improved features, please contact us at [email protected] and we can discuss how we can help you. Below, you can find a description of all new features that have been introduced in AIMMS 4.5.

    Web-based UI extended with ‘sticky widgets’

    The web-based UI has been extended with the option to fix the location of one more widgets, so that the responsive design functionality does not (re)arrange them when the size of your browser tab changes.

    Web-based UI extended with a basic Gantt Chart widget

    The web-based UI has been extended with a basic Gantt Chart widget.

    For more information on how to use this new widget, see this page.

    AIMMS 4.4 Release

    Here you can read about the new features in AIMMS 4.4. More details can be found in the release notes. AIMMS 4.4 and its release notes can be downloaded here.

    Features introduced in AIMMS 4.4 (March 2015)

    If you have any questions on these new or improved features, please contact us at [email protected] and we can discuss how we can help you. Below, you can find a description of all new features that have been introduced in AIMMS 4.4.

    Web-based UI extended with the TreeMap widget

    The web-based UI has been extended with the TreeMap widget, to provide you with the possibility of an alternative presentation of your AIMMS data.

    Cell coloring based on values in Web-based UI

    Cells in the web-based UI can now be colored distinctly, depending on their specific values. Using this functionality you can, for example, present negative numbers in the color red and positive numbers in the color green.

    Basic case comparison in web-based UI

    Basic support for case comparison has been implemented in the web-based UI.

    New version of KNITRO: KNITRO 9.1

    There is a new version of KNITRO, i.e. KNITRO 9.1, which introduces a new Sequential Quadratic Programming (SQP) algorithm for continuous problems. This new SQP algorithm is primarily designed for small problems, where the computational cost is dominated by function/derivative evaluations.

    New version of BARON: BARON 15

    There is a new version of BARON, i.e. BARON 15, which can use parallel threads for solving problems with integer variables. Also the COIN-OR solver FilterSD can now be selected as the NLP solver.

    Further work on the parallelization of the AIMMS engine

    After the start of the parallelization of the AIMMS engine in version 4.3, we have continued our developments in this area. We will keep releasing the results of our ongoing work in gradual, incremental improvements.

    AIMMS 4.3 Release

    Below you can read about the new features in AIMMS 4.3. More details can be found in the release notes. AIMMS 4.3 and its release notes can be downloaded here.

    Features introduced in AIMMS 4.3 (January 2015)

    If you have any questions on these new or improved features, please contact us at [email protected] and we can discuss how we can help you. Below, you can find a description of all new features that have been introduced in AIMMS 4.3.

    Web-based UI around AIMMS models

    A development environment for creating a web-based UI around your AIMMS model, to be hosted through the AIMMS PRO platform. At this stage, the AIMMS web UI contains a fairly limited set of features, which will be extended through multiple small improvements using our new agile development approach.

    Only installation-free executables

    To make sure that AIMMS developers can keep up with the increased release frequency more easily, AIMMS will only be made available in the form of installation-free executables from version 4.3 onwards. Installers will no longer be available.

    Installation-free AIMMS Launcher

    To make working with multiple installation-free AIMMS versions easy, we also provide an installation-free AIMMS Launcher, which

    • provides right-mouse menu items in Windows Explorer to start AIMMS projects either with the closest available AIMMS version or with an AIMMS version selected by the user from the list of available AIMMS versions,
    • lets you manage the collection of installation-free AIMMS versions present on your system,
    • offers support to use the Excel add-in and the AIMMS COM object with any of the available AIMMS versions on your system.

    Parallelization of the AIMMS engine started

    In the past few months we have started working on the parallelization of the AIMMS runtime engine using our new agile development approach. We will release the results of this effort in gradual, incremental improvements. By parallelizing calculations in AIMMS models computation times can be significantly reduced.


    Newfile

    User manual for Ortho4XP version 1.11 released January 19th 2016Contents1 Introduction 22 Installation 33 First test tile in Brittany 44 Custom DEM and zoomlevel in Grand Canyon 95 Sloped runway in the Alps 136 Reference/technical notes 186.1 Water options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186.2 Sea equiv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196.3 Custom and base Zoomlevels . . . . . . . . . . . . . . . . . . . . . . . . . . 196.4 Min area . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196.5 Curv tol / Min angle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206.6 Custom DEM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206.7 Skip downloads/converts . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216.8 User defined vs Automatic masks . . . . . . . . . . . . . . . . . . . . . . . 216.9 Read/write Config . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216.10 Stop process (cleanly) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216.11 Ortho4XP.cfg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216.12 Carnet d adresses.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227 Caveats/F.A.Q. 227.1 My airport has bumpy runways . . . . . . . . . . . . . . . . . . . . . . . . 227.2 Part of my new tile is flooded with water . . . . . . . . . . . . . . . . . . . 227.3 Step 2 will not terminate or with an error :-( . . . . . . . . . . . . . . . . . 227.4 Step 3 complains about no place left in the pool ! . . . . . . . . . . . . . . 237.5 Help! Do I need to erase my tile and resume from start ? . . . . . . . . . . 237.6 A few orthophotos are corrupted with white squares. . . . . . . . . . . . . 238 Acknowledgements 24 1

    1 IntroductionOrtho4XP is a cross-platform open source tool whose primary aim is to build orthophotosbased sceneries for the X-Plane 10 flight simulator at the cost of a few mouse clicks.The building process is not based on existing sceneries or meshes, neither on Laminar’sMeshtool, but instead relies exclusively on : • Openstreetmap for information regarding airports, coastline, rivers, lakes, docks etc. • Elevation files whose data is used to construct altitudes but also to adapt mesh density to local terrain complexity. • Tile Map Services (TMS) which serve as providers for the orthophotos1. The DSF files produced by Ortho4XP contain only the bottom layer of the X-Planescenery hierarchy : a base mesh, that is a set of textured 3D triangles covering the wholetile2. In particular, information such as road networks, forest polygons, buildings, andmore generally anything which is an overlay over the mesh is not part of the Ortho4XPtodo list. There are very good third party resources for the later which complementperfectly and without intersection3 with Ortho4XP, in particular World2XPlane and/orlocal sceneries. Besides the basic features related to download and attribution of textures, one can listthe following regarding the building process and/or its output : 1. A graphical interface that allows to select different zones with different zoomlevels and/or providers directly inside the software. 2. A user controlled global mesh complexity, which covers the range between the stock global scenery and ultra high density meshes, actually way beyond, with only a limited impact on runtime. 3. Transparency/blending effects for inland and sea water. The first through a con- figurable alpha channel ratio, and the second through the automatic generation of blured alpha masks following the coastline. 4. Every airport whose boundary is defined in Openstreetmap is automatically flat- tened along its boundary. 1The copyrights regarding these services should be considered seriously. Fortunately the majority ofthem tolerate private non commercial “fair” use, and an increasing number of them are even going opendata. The INSPIRE European rule is a really nice move in that direction. 2Strictly speaking transparency water effects are obtained by a combination of base triangles of X-Plane water type with overlay masked triangles textures with orthophotos. 3Even though X-Plane deals pretty well with the abundance of repetitive information through itsexclusion processes, it also certainly influences its load time at least. 2

    5. The ability to patch the mesh at the very early stage of the building process, in particular to easily burn in well rounded sloped runways, or to flatten specific areas at a fixed altitude.2 InstallationThe installation of Ortho4XP per se is only a matter of decompressing the included 7zarchive to your prefered location on disk. Keep in mind that orthophotos based scener-ies are demanding in terms of file size, and therefore it is presumably a good idea tochoose a partition with a comfortable amount of free space. Also, on Linux and OSX you should check after decompression of the archive that the files Ortho4XP.py andUtils/Triangle4XP (Linux) or Utils/Triangle4XP.app (OS X) have the appropriateexecution rights. In case not, these can be recovered issuing chmod a+x Ortho4XP.py forthe first one, and chmod a+x Utils/Triangle4XP for the second. The evil before you can start building tiles is hidden in the fact that Ortho4XP isnot a standalone software. It requires a number of (open source) software packages asprerequisites. Note however that you won’t need to use them directly, but Ortho4XP will.These are : • A Python 3 interpreter along with the following extra Python modules: requests, numpy, overpy, tk and (optional) gdal and pyproj. • Imagemagick (for convert and montage command-line tools), version >= 6.8 pre- ferred. • nvtools nvcompress -the NVidia Tools Extension (provides a cross platform dds library)To be able to use Ortho4XP to its full extent the following additional software should bepresent as well : • Gimp and/or Netpbm (process times being shorter with the first of these two). Whatever the way you follow to install these prerequisites (in particular the onesoutlined in the README.install), you are strongly encouraged to perform the followingtests after installation to check whether everything is in order : 1. Fire up your Python 3 interpreter, e.g. through a command terminal window. (check that you indeed launched Python 3, not e.g. version 2.7 which may coexist alongside on many systems) 2. At the Python prompt issue import requests, overpy, numpy, tk. You should only obtain a new command prompt and no error messages. 3

    3. Do the same with the command from PIL import ImageTk. Here again you shouldn’t obtain anything more than a new command prompt. 4. Exit the Python interpreter (e.g. with the command quit()). 5. In a command terminal window of your OS, issue convert -list format (or convert.exe -list format if on Windows). You should obtain a (long sorted) list of delegates available to Imagemagick, and DDS* DDS rw+ Microsoft DirectDraw Surface should be one of those. If you additionally wish to be able to automatically build transparency masks forcoastlines (or so-called sea equiv user-defined regions), you should succeed in at least oneof the following two tests : 6. Netpbm is present on your computer and possesses the executable pamundice (other required executable are assumed to be present if pamundice is). 7. Gimp is present on your computer and issuing the command gimp -i -c -b ’(blurX \"test.png\" 16 \"result.png\")’ -b ’(gimp-quit 0)’ from within a terminal window in the directory /Utils should produce a png file called result.png in that same directory, which can be opened with an image viewer. You will most probably need to copy the file blurX.scm, found in the directory Utils, to the script-fu directory of your Gimp install (e.g. $HOME/.gimp-2.8/scripts/ on Linux and Max OS X).If you succeeded in installing the preceding prerequisites, congratulations, you may nowembark in using Ortho4XP !3 First test tile in BrittanyIn this section we shall follow step by step the creation of a first tile using only basicfeatures. The tile corresponds to the Ouessant island in the extreme west of Brittany inFrance. Since the land cover of that tile is small, the whole process shouldn’t take longerthan a couple of minutes (in addition to the ones you’ll be employing reading these notescarefully of course!). We begin by launching the application Ortho4XP (the heart of the application isthe source file Ortho4XP.py). Depending on your system and the file associations whichyou have configured, you may simply have to double-click the file Ortho4XP.py in a filebrowser (prefered way), or else to issue the command python3 ./Ortho4XP.py (Linux,OS X) or py.exe -3 Ortho4XP.py (Windows), possibly replacing the Python interpretername depending on your exact set-up. We are now in front of the main window (Figure 1). At the top of that window, wecan read the latitude and longitude coordinates of the tile to be built (these follow thesame rules as X-Plane, i.e. they correspond to the coordinates of the point at the south 4

    west corner of the tile). For this first tile, we will leave the default values 48 -6 whichindeed correspond to the Ouessant island. We will also leave the custom build dircheckbox unchecked, so that we will construct the tile within the default (and newlycreated) directory called zOrtho4XP +48 -006 (within the main Ortho4XP dir). We step forward to the “Zoomlevel and Water options” section. The base providerand base zoomlevel for the tile are given in the first two listboxes. Since Ouessant is only6 squared miles, we can safely increase the base zoomlevel to, say, 18, whereas for theprovider we shall choose the local ’FR’ source, but the default ’BI’ would be a very goodchoice too. We shall not define additional custom zoomlevels for this first tile, and stick tothe “Mixed with transparency” water option which is certainly the nicest one (the othertwo are left either for very low end configurations or for specific tasks not described here). The parameter ratio water is related to the proportion of “X-Plane water” in itsblending process with water from orthophotos, only for inland water. For the presenttile, that will only apply to two small patches of water right in the middle of the island, andis therefore not of the utmost importance. The default value can actually be considereda good value for any tile, but that may depend on user taste. Now comes the first real step, in section “Build vector data (OSM/Patches)”, wherewe will download all vector data related to boundaries of ground with water as well asof airports from Openstreetmap. The parameter Min area represents a surface in squarekilometers: Every single closed loop of water whose surface is less than this value will bediscarded in the building process. In principle one could simply set it to 0, to get thefull Openstreetmap data. In practice, this is not always the best option because this canimply a higher complexity for the mesh while transparency effects become barely visiblewhith decreasing surface area. For this first example we can safely take it to be 0 though. Check that your internet connection is working and click (once!) on the button “Step1 : Build vector data”. The right terminal pane of the window should start to animateitself and you’ll get information on the process until completion indicating process time.For Ouessant, this shouldn’t take much more than a few seconds. Before we jump to Step 2, let us have a look at Figure 2 showing the vector data thatwe have just processed (contained in Data+48-006.poly in the folder zOrtho4XP +48-006below the main Ortho4XP directory).Besides the coastline, one can see the boundaries of LFEC airport (east), the two patchesof inland water (center), and of course the grid, which corresponds to the trace cut ofpotential ZL19 orthophotos (even though we will not use such high zoomlevels here, themesh will be ready to support them). In Step 2, we have to decide a value for the parameter Curv tol. It is very importantto understand the meaning and the importance of that parameter, which is related to thecomplexity of the mesh to be created. Its acronym stands for “tolerance to curvature”,and therefore the higher it is, the higher tolerance is, and the lower mesh complexity will 5

    Figure 1: Main window (croped)be. When a terrain is bumpy, it requires a higher density of mesh points to approximate itwithin a certain tolerance, with respect to a flat terrain. The parameter Curv tol controlshow far in the refinement the mesh algorithm will go to approximate the mesh to reality.In regions which are not terrifically bumpy as in Ouessant, a low value, such as as say 0.2, 6

    Figure 2: Vector data (croped around the island)can be used to get a fine approximation. In the mountains like e.g. the +45+006 tile, ahigher value of 3 will already give a very complex mesh, and a value of 0.2 there wouldcertainly lead to a mesh way too heavy (and which will actually fail to be transformedinto a dsf). There is no black magic here, and you”ll surely quickly get acquainted withthis parameter. Also, we will get information regarding our mesh complexity, and thepossibility to revert to different values of the parameter as many times as we please, afterwe launch the Step 2 button right now: As we can see, our mesh has 58032 triangles. This is not a lot in absolute value,compared to the global scenery tiles of X-Plane that have something like 500.000 triangles.Or course this has to be put in relation with the size of the island. In the next figurewe can have a closer look at the triangles of the mesh (file Data+48-006.1.ele). To getan idea of their size, keep in mind that any box of the grid is roughly 800m of lateralsize (this actually varies depending on latitude), so that triangles here range somewherebetween 20m for the smallest and 200m for the largest (and even 800m for those fullyoffshore). What we can observe as well is that the vector data of Step 1 is present as so-called “required-edges”, meaning that they are part of the triangles edges, and the lattertherefore do not have transverse intersection with the vector data (in straight terms: themesh respects the terrain boundaries). As we can see also, a small proportion of the triangles have a pretty small smallestangle. This is generally something that people working with meshes try to avoid, inparticular when computations need to be done with those meshes. Within X-Plane, thereis not quite such a rule, but in specific cases that may help and that is the goal of the 7

    Figure 3: Outcome of Step 2 in this examplecheckbox Min angle which we haven’t used here (its usefulness is mainly in order whendealing with the more advanced feature of - Patches - or user-customized local mesh).Furthermore, you could ask yourself where the elevation data that the mesh algorithmhas been using came from. In this specific case, it turns out that the elevation file forthe +48-006 tile is included (and this is the only one) in the 7z archive coming alongOrtho4XP. This file is located in the directory Elevation data, which is the defaultlocation where the software is looking for them, unless we specify something different inthe Custom DEM file file chooser. We are ready to proceed to the last step, and since we wish to avoid a harsh transitionbetween the land of the island and the sea, we shall build transparency masks. Basically,these are b&w png files which will eventually serve as BORDER TEX in X-Plane’s terrainfiles, and which are obtained in the following way : first a binary black and white image isconstructed from the information of the mesh, with white pixels for ground and black onesfor water. These are then blured according to the blur radius indicated in the Masks widthentry, and then leveled up for artistic purposes. In rough terms, one pixel of blur radiuscorresponds to 10m of offshore data. The higher the Masks width the smoother thetransition, but we are limited by the location over the sea where orthophotos starts tolook bad (typically completely white or a plain saturated blue). In Ouessant and with 8

    Figure 4: Mesh densitythe ’FR’ provider, we can safely ask for a Masks width of 32. We push the “(Step 2.5 :Build Masks)” button and wait for completion. If you are relying on Gimp the processwill be fast (under one minute), whereas the combination Imagemagick/Netpbm will needalmost an order of magnitude longer (we are dealing with images that are approximately600 Mpix in size. ). In any case, keep in mind that process time is somehow proportionalto the value of Masks width. Finally, we push the “Step 3 : Build Tile” button and wait for completion. Oncefinished, the directory zOrtho+48-006 can be used directly within the Custom Sceneryfolder of X-Plane. One convenient way to process, that will save your disk from unneces-sary read/write cycles in the future, is to make a simlink inside Custom Scenery to yourtile directory. In Linux or OS X, that would amount tocd [Custom Scenery location] && ln -s [Ortho4XP location]/zOrtho4XP +48 -006 ./zOrtho4XP +48 -006Simlinks can also be made under Windows, but notice that these are not the same as“shortcuts”. Proceeding this way, later modifications that you could make to your tile(s)would be directly effective within X-Plane. Now we can have a break and enjoy a bit our preferred flight-simulator over our newlycreated tile. Head-up towards LFEC !4 Custom DEM and zoomlevel in Grand CanyonFor this section we cross the Atlantic ocean to land at Grand Canyon National ParkAirport (KGCN). Time has arrived to discuss about elevation files. These are squared or rectangular 9

    tables that describe earth elevation (AMSL) over a regular grid (one entry for each pointon the grid). These grids may sometimes be found in different geographic referencecoordinates, for X-Plane we shall need the WGS84 one. These can also be found indifferent file formats, and Ortho4XP requires either the Geotiff or the HGT formats.Finally, it is important for Ortho4XP that the boundary of the DEM data correspondsprecisely to the boundary of the tile, and that the grid is of a squared ratio. There areat least two places at least where we can obtain this kind of data with the appropriateformat: • The website viewfinderpanorama, maintained by Johnathan de Ferranti, who does a spectacular job at gathering the best available data from all possible publicly available sources. You’ll find there DEM in the HGT format which have either a 3” arc resolution (roughly 90m) or in certain places a 1” arc resolution (roughly 30m). • The website gdex.cr.usgs.gov maintained by USGS, where you’ll find void filled SRTM data with a 1” arc resolution. The correct format to choose from is “Geotiff 1x1 tile”. Free registration is required to access the data.In both cases, you need simply drop the .hgt or .tiff file in the Elevation data dir.Their names must look exactly like4 N36W113.hgt and SRTMv3 1 N36W113.tiff, and thenfollow the same rule wherever on earth (except the poles). If both files are present for thesame tile, the priority is given by Ortho4XP to de Ferranti’s version (higher resolutiondoes not always translates into higher quality). As one could expect, for Grand Canyon one can find public elevation data with aneven higher resolution. For this example, we shall download the 1/3” arc file from USGSviewer.nationalmap.gov/basic/ (3DEP products → 1/3 arc-second DEM), which inthis case is contained in the archive n37w113.zip due to a different naming scheme (northwest corner). There are two obstacles to face here : first the format .img contained inthe archive is not the one we please (even though they all only differ by a tiny bit)and more importantly it covers a few tens meter more than the tile so that we needto crop a few (6!) lines and columns. With the help of the Gdal library, it is not abig deal to turn it back to the required format and extent, but since we may not allhave it available and since this is not a user manual for Gdal we shall simply downloadit from https://www.dropbox.com/s/gd902e1m4xhr5k0/N36W113.tiff?dl=0 and save itsomewhere on our disk. If instead you prefer to do it yourself (and hence preserve my Drop-box download quota!), or wish to see it for a different tile, the command is gdal translate-srcwin 6 6 10801 10801 -of GTiff imgn37w113 13.img N36W113 bis.tif. We can now fire up Ortho4XP and select the tile 36 -113. For the base provider weshall choose ’GO2’ with a ZL16 base zoomlevel. But now we want some detail within theCanyon, and we proceed to the “Choose custom zoomlevel” button, which opens a newwindow. 4Well the airport is actually just past the border of that tile, but what we really want is the Canyon,not the airport. 10

    We select the source and zoomlevel for for Preview, e.g. ’BI’ with ZL 12. These twoparameters are completely independent of the subsequent choice for the tile orthophotos,and therefore we may choose them freely. In Europe or where OSM data is abundant, itis generally a good idea to stick with the default ’OSM’ provider. Here is turns out thatthe width of the Canyon is difficult to guess on OSM, the reason why we went for ’BI’. We push the “Preview” button, and after the download is completed an image of thewhole tile appears on the screen. For the ease of selection, an area a bit larger than the1 degree tile is actually shown, and the tile boundary appears as a black solid line. Fromthere, we shall do the following: 1. select ’GO2’ source in “Zone params”. 2. select the ZL19 red radio-button. 3. draw one polygon to be filled with ZL19 by ”shift+clicking” each point to be added, in this example it corresponds to the bottom of part of the Canyon. 4. push the “Save zone button”. 5. select the ZL18 orange radio-button. 6. draw a polygon a bit larger than the ZL19 one, which covers the whole width of the Canyon. 7. push the “Save zone button”. 8. push the “Save and exit button”.Please note, that the last two savings do not play the same role, and it is important not toskip the penultimate or the last zone will not be kept at build time. You may also noticethat each time a zone is saved, a rough indication of the disk size the corresponding DDStextures will occupy (in total) appears in an entrybox. That may also serve as a goodindication of which zone you are currently editing, if you start playing editing, deleting etc.You may indeed freely experiment with zones, they may overlap, have different providers,etc. The “back space” key will erase the last point of the zone currently in edition, and the“p” key as the same effect as “shift+click”. At build time the different zones will be firstbe sorted by decreasing ZL, so that in case of overlap the option with the largest ZL willbe chosen (in particular in the example depicted below the ZL18 textures correspondingto the bottom of the Canyon will not be downloaded, even though the corresponding zonecovers it).Also, if you wish to change Preview provider and/or zoomlevel for Preview, withoutloosing the polygons that you have already encoded, push “Save and exit”, then go backwith the “Choose custom zoomlevel”, select your new choice and you should recover yourpolygons at the right position. 11

    Figure 5: Example ZL choice in Grand Canyon We go on with Step 1 as we have already learned, and since there isn’t quite muchOSM data past the Colorado river we may as well choose Min area=0, but for the samereason it wouldn’t change much either to stick with the default value of 0.01. The important choice comes at Step 2 where we need to decide about the value al-located to Curv tol. Surely the Canyon is bumpy, and we should be tolerant enough.A general rule when bumpy terrain is suspected is to start with a value of 3, which willthen be adapted if needed. We next click the “Custom DEM” checkbox and use the filechooser to select our custom made N36W113.tiff. Step 2 button then performs his joband provides us with a mesh with 1.848.556 (the actual number may vary slightly whenyou’ll try it yourself because the meshing algorithm contains some randomness), whosedensity is depicted (only in some small part) here below in Figure 6. The UHD meshes of Alpilotx contain something like 3.5 million triangles per tile, andhere we wish to push the limits a little bit to see how much we can grab from our detailedDEM (the later has 3*3600 to the square input points, which is roughly 100 millions! -but only a small proportion of these really have value, those that are in the Canyon and 12

    Figure 6: Density of Mesh points for Curv tol = 3not the ones on the plateau). So we decrease the value of Curv tol say to 1.5 and oncemore press the Step 2 button. Still not in accordance with our present braveness. Onlywhen we finally reach Curv tol=0.5, the value of 5 Millions triangles start to make usdoubtful, and we shall stop here for today. We finally press the Step 3 button (no masks are needed on this tile which do notcontain any coastline). After completion, perhaps we will meet playing the fool inside theCanyon -) http://www.youtube.com/watch?v=PFIcVbeHX7w5 Sloped runway in the AlpsThe aim of this section is to present another functionality which we haven’t used up tonow : patch files. This feature will probably be (blindly) used by most of the users whenflying in mountainous regions, but only few of them will probably embark in buildingtheir own patch (although, as the video below will show, the process is quite simplifiedby JOSM). The developers of 3D sceneries are hence the primary target of this section. Not all airports have a flat runway in real life, and some of them are really far from.Typical examples are Courchevel (LFLJ) and L’Alpe d’Huez (LFHU) in France, whoserunways are sloped and rounded. The reproduction of these two airports, either in the Global Scenery or in most ofits higher density extensions, are missing some of the special features which characterizethem. Similarly, without a patch file the mesh obtained using Ortho4XP for sloped 13

    Figure 7: Density of Mesh points for Curv tol = 0.5airways would be either completely flat (e.g. LFLJ and LFHU, since their boundary iswell defined in OSM), or absurdly bumpy (because most DEM file suffer from acquisitionnoise, an even without it wouldn’t be able to reproduce at sufficiently small scale theroundedness). Patch files come into play at the level of Step 1, and therefore they play asimilar role as OSM do in defining some closed polygons which are to be assigned withtags. Whereas a closed way of water is assigned a tag telling whether it is inland or seawater, a patch defined through a patch file for a sloped runway will be tagged (withinJOSM) by its altitude high, altitude low (and optionally by its profile, steepnessand cell size). Even more simply, a patch whose aim is to flatten a piece of land willjust be tagged by its target altitude. The latter can be particularly useful in slopedterrain so that buildings are not flying over the ground with just one corner touching. Patch files are automatically processed by Ortho4XP when present in the Patchessubdirectory, corresponding to their Latitude/Longitude, provided their filename has thesuffix .patch.osm. A small number, in particular those for LFHU and LFLJ, are alreadypresent in the 7z archive. They may be adapted freely, and developers of 3D scenerieswho wish so are in particularly welcome to provide the community with patch files suitedto their creation. Note that patches do not need to be related in any way to an airport,and can be used to flatten any polygonal area5, e.g. an airport otherwise not encoded inOSM (patch is local and yours, so it can be quite approximate, whereas when uploadingdata to OSM you should be much more careful). Making a real-time video of the process was found to be easier (certainly to do but 5provided it does not intersect transversally another patch, in particular a water patch! 14

    perhaps also to understand) than this manual. The one for LFHU can be found here : http://www.youtube.com/watch?v=4Q3q5Lq4Kisand snapshots for the comparison before/after are in the two figures on the next page. 15

    Figure 8: LFHU without patch is wrongly flattenedNote that not only the runway is flat in the first image, but also that the parking andpart of the tennis courts are instead sloped ! Figure 9: LFHU with a patchThis second one looks more natural, and 3D objects will be welcome to give a bit of lifeto this wonderful but otherwise dull landscape! (and X-Plane does not have the runwayexactly at the right position but that can be corrected independently) 16


    Watch the video: Mapping Solar Energy: Working with HERE Studio Vector Tiles u0026 Tangram (October 2021).