POST
|
Hey Gonzalo - You might want to take a look at the approach (and code) described in this blog: https://community.esri.com/community/developers/native-app-developers/arcgis-runtime-sdk-for-net/blog/2018/03/29/label-features-the-easy-way. In addition to making the code easier to work with and maintain, you have some control over how the values you're using are returned (int vs string, etc.). Thad UPDATE: Sorry, after taking a closer look I see that the problem you're facing is getting the expression "return $Feature.MinScale" to provide an integer from the underlying string value. I'm not sure, but it looks like the Arcade "Number" function might do the trick: Data Functions | ArcGIS for Developers
... View more
02-08-2019
12:37 PM
|
1
|
6
|
1211
|
POST
|
Hi! This is the space for ArcGIS Runtime SDK, it sounds like your question belongs in the ArcGIS Pro SDK space: https://community.esri.com/groups/arcgis-pro-sdk
... View more
12-03-2018
10:55 AM
|
1
|
0
|
1180
|
POST
|
Hey Kevin - One way to do this is to handle the GeoView.GeoViewTapped event to get a map location, then project the point (if necessary) to get the geographic coordinates (longitude and latitude). Here's an example: mapView.GeoViewTapped += (s, e) =>
{
double latitude;
double longitude;
// Get the point clicked (it will be in the map's coordinate system, which may not be geographic).
MapPoint mapPointRaw = e.Location;
if(mapPointRaw.SpatialReference != SpatialReferences.Wgs84)
{
// Project the click point to geographic coordinates.
MapPoint mapPointLatLong = GeometryEngine.Project(mapPointRaw, SpatialReferences.Wgs84) as MapPoint;
longitude = mapPointLatLong.X;
latitude = mapPointLatLong.Y;
}
else
{
// No need to project, point is already in geographic coordinates.
longitude = mapPointRaw.X;
latitude = mapPointRaw.Y;
}
}; You can also use the MapView.SketchEditor to get geometry from the user (not just points, but also lines or polygons, etc). You can make a call like this from a button click event to get a map point. Like the previous example, this point will be in the spatial reference (coordinate system) of the map. You may need to project it to get latitude/longitude coordinates. MapPoint mapPointRaw = await mapView.SketchEditor.StartAsync(SketchCreationMode.Point) as MapPoint; Hope that helps! Thad PS - here's a sample that illustrates providing tools for the user to sketch geometry on the map that you might find useful: Sketch graphics on the map—ArcGIS Runtime SDK for .NET Samples | ArcGIS for Developers
... View more
06-15-2018
10:28 AM
|
0
|
0
|
1729
|
POST
|
Hey Michael - I suspect the problem is that you are reading the travel modes array for a different network than the one you are using for the `RouteTask`. The parameter values (such as "AVOID_MEDIUM") need to map to one of the values in the `RestrictionAttributes` for the `RouteTask` (you can check `RouteTaskInfo` to see a list of these). Try code like the following to 1) create a route task and get its default parameters, 2) read the available travel modes for the network, 3) iterate all modes, and 4) find the mode for pedestrian travel ("WALK") and use it in the parameters. // Create the RouteTask using the world routing service.
var routeTask = await RouteTask.CreateAsync(new Uri("http://route.arcgis.com/arcgis/rest/services/World/Route/NAServer/Route_World"));
// Get the default parameters for the task (which uses driving as the travel mode).
var routeParams = await routeTask.CreateDefaultParametersAsync();
// Get the available travel modes from the RouteInfo. Iterate all modes.
var routeInfo = routeTask.RouteTaskInfo;
foreach (var mode in routeInfo.TravelModes)
{
// Find the travel mode of type "WALK".
if(mode.Type == "WALK")
{
// Assign this as the travel mode for the route parameters, then exit the loop.
routeParams.TravelMode = mode;
break;
}
} Hope that helps, happy routing! Thad
... View more
04-09-2018
01:25 PM
|
0
|
0
|
538
|
BLOG
|
The good news: Features and graphics in your ArcGIS Runtime SDK for .NET app can be labeled using a combination of attribute values, text strings, and values calculated with an expression. You can set font characteristics, determine how labels are positioned and prioritized, and how conflicts between overlapping labels are automatically and dynamically resolved. By creating one or more label classes, you can define distinct labels for groups of features. The bad news: As of the 100.2.1 release, there's no API exposed for this. To implement labeling for a feature layer, graphics overlay, or map image sub-layer, you need to craft the appropriate JSON definition (text) to define your label classes (as described here). Bummer. But don't worry, a simple JSON serializable class is all it takes to simplify your labeling code. I'll walk you through the basic process in the steps below. If that's still too much work for you, feel free to simply download the attached code and try it out. The labeling class in the project (LabelClassInfo.cs) can be brought into any ArcGIS Runtime for .NET project and used to create labels for your layers. Start Visual Studio and create a new ArcGIS Runtime SDK for .NET app. Add a new class to the project. Let's name it LabelClassInfo.cs. Add the following using statements at the top of the class. using Esri.ArcGISRuntime.Geometry;
using Esri.ArcGISRuntime.Symbology;
using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json; Decorate the class with the DataContract attribute. This indicates that the class will be serializable. [DataContract]
public class LabelClassInfo
{ Create properties for everything expected in the JSON definition of the label class. This information is defined under labelingInfo in the Web map specification. The specification defines an "allowOverrun" value, for example. This could be implemented with the following simple bool property. Note that the name of the property in the class does not need to match the name in the specification. public bool AllowOverrun { get; set; } Based on the specification, here are the properties (and corresponding data type) needed for the label class: allowOverrun (bool), deconflictionStrategy (string), labelExpression (string), labelExpressionInfo (object), labelPlacement (string), minScale (int), maxScale (int), name (string), priority (int), removeDuplicates (string), removeDuplicatesDistance (int), repeatLabel (bool), repeatLabelDistance (int), stackLabel (bool), stackAlignment (string), symbol (TextSymbol), useCodedValues (bool), where (string). OK, the list above looks pretty straightforward, except for the two properties that don't return primitive data types. Go ahead and create properties for everything except labelExpressionInfo and symbol (we'll circle back to those). After you've defined the properties, in order to make them serializable you'll need to decorate them with the DataMember attribute. The string you supply for "Name" will be used in the output JSON and must match the name used in the Web map specification. Add the appropriate DataMember attribute to all properties. [DataMember(Name = "deconflictionStrategy")]
public LabelPosition LabelPosition { get; set; } The labelExpressionInfo property, returns object. What kind of object do we need here? In the specification, the JSON describes a class with a single property (not counting the deprecated "value" property). You'll therefore need to create a new private class (nested under your main class) with a single property that holds a (string) expression. This class will also be serializable, so you need the DataContract and DataMember attributes. [DataContract]
private class ExpressionInfo
{
[DataMember(Name = "expression")]
public string Expression { get; set; }
public ExpressionInfo(string expression)
{
Expression = expression;
}
} The labelExpressionInfo property should be based on the new ExpressionInfo type. To simplify the API, you might want to expose just the expression property (ArcadeExpression in the example below) and build the ExpressionInfo object that contains it internally. [DataMember(Name ="labelExpressionInfo")]
private ExpressionInfo _labelExpressionInfo = new ExpressionInfo("");
public string ArcadeExpression
{
get { return _labelExpressionInfo.Expression; }
set { _labelExpressionInfo = new ExpressionInfo(value); }
} What about the symbol property that returns TextSymbol? You can handle this is much the same way: expose a public Symbol property of type TextSymbol, then use an internal property to get its JSON representation (yes, Esri.ArcGISRuntime.Symbology.Symbol is serializable!). public TextSymbol Symbol { get; set; }
[DataMember(Name = "symbol")]
private string SymbolString
{
get { return this.Symbol.ToJson(); }
set { this.Symbol = (TextSymbol)TextSymbol.FromJson(value); }
} Finally, create a method on LabelClassInfo to return the JSON representation of the object. public string GetJson()
{
// Create a JSON serializer for the label class.
DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(LabelClassInfo));
// Write the object to a memory stream.
MemoryStream stream = new MemoryStream();
jsonSerializer.WriteObject(stream, this);
// Read the stream to a string.
stream.Position = 0;
StreamReader reader = new StreamReader(stream);
string json = reader.ReadToEnd();
// HACK: clean up the json a bit.
json = json.Replace("\"{", "{").Replace("}\"", "}").Replace("\\", "\"").Replace("\"\"", "\"");
// Return the serialized string.
return json;
} You should now be able to use the new LabelClassInfo class to write code like the following to apply labels to a feature layer! TextSymbol textSymbol = new TextSymbol
{
FontFamily = "Arial",
FontWeight = weight,
Size = (int)TextSizeComboBox.SelectedValue,
HorizontalAlignment = Esri.ArcGISRuntime.Symbology.HorizontalAlignment.Left,
VerticalAlignment = Esri.ArcGISRuntime.Symbology.VerticalAlignment.Bottom,
Color = (Color)ColorComboBox.SelectedValue
};
// Create a new LabelInfo object and set the relevant properties (including the text symbol).
LabelClassInfo labelInfo = new LabelClassInfo()
{
LabelPosition = "static",
ArcadeExpression = "return $feature['" + LabelFieldComboBox.SelectedItem + "'];",
MinScale = 0,
MaxScale = 0,
Priority = 30,
RemoveDuplicateLabels = "featureType",
StackLabel = true,
Symbol = textSymbol
};
// Get the raw JSON from the label info object.
labelJson = labelInfo.GetJson();
// Create a new label definition from the JSON string.
LabelDefinition labelDef = LabelDefinition.FromJson(labelJson);
// Clear existing label definitions.
_parcelsLayer.LabelDefinitions.Clear();
// Add the new label definition.
_parcelsLayer.LabelDefinitions.Add(labelDef); OK, so it might not be the easiest thing to code, but once you have it you can reuse this class anytime you need to add labels for a layer. Apologies if the steps above were too vague or if you got stuck because I left something out! I've attached a project with the LabelClassInfo class and a WPF app for testing. The attached example also includes some enums for defining label position, placement, and handling of stacking and duplicates. Update (2018 March 13): I've attached a much cleaner version of the LabelClassInfo class ("LabelClassInfo2.cs") that uses Newtonsoft.Json (thanks to Matvei Stefarov on the ArcGIS Runtime SDK for .NET team). Including a link to a a utility that helps create your serializable class from JSON: Instantly parse JSON in any language | quicktype
... View more
03-28-2018
06:21 PM
|
4
|
2
|
2478
|
BLOG
|
If you've ever had to show the density of point features on a map, you may already be familiar with the concept of a heat map, which allows you to generalize the display of points according to their density. A heat map provides an excellent tool for discovering patterns in your data. In addition to looking at density of point location, you can also provide a field in your dataset with which to weight the density. This allows you to look at the density of things like sales (dollars, for example) instead of just the density of customers over an area. Heat maps are displayed with a color ramp that usually shows dense areas with a darker color (red, for example) and sparse areas with a light color (such as yellow). You may have used a heat map renderer to display your point data in the ArcGIS Online map viewer or ArcGIS Pro. The heat map below shows the density of earthquakes weighted with a field that contains the magnitude. "Sounds great". You might be saying. "I'm excited to try it in my ArcGIS Runtime for .NET app"! "Um, yeah. About that." I would say, sheepishly looking at my shoes. While there is support in ArcGIS Runtime for reading things like a heat map renderer from a web map, there's no API exposed (as of v100.2.1) that allows you to construct one and apply it to a point layer without crafting the raw JSON definition. Fortunately, with a little effort, there's a way to make it much easier to work with. In a previous blog, I described how to create a serializable class to define labeling properties to apply to a layer. I'll describe the same technique here to define a heat map renderer class that can be serialized to JSON and applied to your point layer. If you don't really care about the details and just want to start using it, you can download the completed class and sample project and give it a try. Start Visual Studio and create a new ArcGIS Runtime SDK for .NET app. Use the NuGet Package Manager to add the Newtonsoft.Json package to the project. Add a new class to the project. Let's name it HeatMapRenderer.cs. Add the following using statements at the top of the class. using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Windows.Media; Create properties for everything expected in the JSON definition of the heat map renderer class. This information is defined under heatmapRenderer in the Web map specification. The specification defines a "blurRadius" value, for example. This could be implemented with the following simple long property. Note that the name of the property in the class does not need to match the name in the specification. public long BlurRadius { get; set; } Based on the specification, here are the properties (and corresponding data type) needed for the heat map renderer class: blurRadius (long) colorStops (list of objects) field (string) maxPixelIntensity (double) minPixelIntensity (double) type (string). OK, the list above looks pretty straightforward, except for the property that returns a list of objects. Go ahead and create properties for everything except colorStops (we'll circle back to that one). The Type property needs to be set with "heatmap" as the default, as shown here. public string Type { get; set; } = "heatmap"; After you've defined the properties, in order to make them serializable you'll need to decorate them with the JsonProperty attribute. The string you supply will be used in the output JSON and must match the name used in the Web map specification. Add the appropriate JsonProperty attribute to all properties, as shown below for the BlurRadius property. [JsonProperty("blurRadius")]
public long BlurRadius { get; set; } The colorStops value is defined with a list of objects. What kind of object do we need here? In the specification, the JSON describes a colorStop class with two properties: color and ratio. You'll therefore need to create a new class with those properties. Let's call the class ColorStop. public partial class ColorStop
{
[JsonProperty("ratio")]
public double Ratio { get; set; }
[JsonProperty("color")]
public int[] Color { get; set; }
} The ratio property is a double. Color is a four value array (R, G, B, A). The constructor for ColorStop will accept a ratio (double) and a Color. The color values are used to set the array. public ColorStop(double ratio, Color color)
{
Ratio = ratio;
Color = new int[] { color.R, color.G, color.B, color.A };
} Return to the HeatMapRenderer class and add a property to hold the color stops. Initialize the property with an empty list of color stops. [JsonProperty("colorStops")]
public List<ColorStop> ColorStops { get; set; } = new List<ColorStop>(); Add some helper methods to add or clear color stops in the collection. public void AddColorStop(double ratio, Color color)
{
if (ratio > 1.0 || ratio < 0.0) { throw new Exception("Argument 'ratio' must be a value between 0 and 1."); };
ColorStop stop = new ColorStop(ratio, color);
ColorStops.Add(stop);
}
public void ClearColorStops()
{
ColorStops.Clear();
} Finally, add a ToJson method that returns the JSON representation of the class. public string ToJson()
{
return JsonConvert.SerializeObject(this);
} You should now be able to use the new HeatMapRenderer class to write code like the following to apply a heat map renderer to a point feature layer! // Create a new HeatMapRenderer with info provided by the user.
HeatMapRenderer heatMapRendererInfo = new HeatMapRenderer
{
BlurRadius = blurRadius,
MinPixelIntensity = minIntensity,
MaxPixelIntensity = maxIntensity
};
// Use a selected field to weight the point density if the user chooses to do so.
if (UseFieldCheckBox.IsChecked == true)
{
heatMapRendererInfo.Field = (FieldComboBox.SelectedValue as Field).Name;
}
// Add the chosen color stops (plus transparent for empty areas).
heatMapRendererInfo.AddColorStop(0.0, Colors.Transparent);
heatMapRendererInfo.AddColorStop(0.10, (Color)StartColorComboBox.SelectedValue);
heatMapRendererInfo.AddColorStop(1.0, (Color)EndColorComboBox.SelectedValue);
// Get the JSON representation of the renderer class.
string heatMapJson = heatMapRendererInfo.ToJson();
// Use the static Renderer.FromJson method to create a new renderer from the JSON string.
var heatMapRenderer = Renderer.FromJson(heatMapJson);
// Apply the renderer to a point layer in the map.
_quakesLayer.Renderer = heatMapRenderer; I'd agree with you if you think this is a lot of code to write to implement a heat map renderer. But remember, this class can be used in all your ArcGIS Runtime for .NET apps when you want to apply heat map rendering. Apologies if you were unable to successfully follow the steps above. Fortunately, the attached project contains the HeatMapRenderer class, as well as a WPF app for testing the heat map renderer.
... View more
03-28-2018
06:20 PM
|
3
|
0
|
1949
|
POST
|
I ran this past someone more knowledgeable with using raster in the runtime, and they suspect it might be a bug. We'll investigate further and try to find a resolution. In the meantime, would it be possible to share one of the images that gives you the problem? If so, you can contact me directly at ttilton@esri.com. If the file zips smaller than 20 megs or so, feel free to simply attach it to an email. Otherwise, we can arrange another way to share it. Thanks, Thad
... View more
03-09-2018
09:19 AM
|
0
|
1
|
985
|
POST
|
Hey Dan, I'm not sure about modifying the locator properties, but you could modify the offset used to display match results in your runtime app. In the match results, the GeocodeResult class provides a RouteLocation and a DisplayLocation. The RouteLocation is a map point along the reference network and the display location is the map point with the display offset applied. Before displaying a result, you could use these points to determine a new offset by doing something like moving the display point closer or further to the route point along a line drawn between them, for example. Hope that helps, Thad
... View more
03-02-2018
01:11 PM
|
0
|
0
|
536
|
POST
|
Hey Marcus, I tested with a JPEG 2000 image I found here, and had no problems displaying the raster layer in an ArcGIS Runtime (WPF) app. A *.JP2 file stores spatial reference info directly in the file using Geography Markup Language (GML). If you open it in a text editor (Notepad++, e.g.), you should see info like this: <gml:ProjectedCRS gml:id="ogrcrs1"> <gml:srsName>NAD_1983_HARN_StatePlane_Delaware_FIPS_0700</gml:srsName> <gml:baseCRS> ... Can you confirm that your image has coordinate system info defined? It might be that ArcMap handles the missing spatial reference by simply assigning a default (?).
... View more
02-28-2018
10:50 AM
|
0
|
0
|
985
|
POST
|
Hi William - I've dealt with this frustration too. You can use something like a FileOpenPicker to choose a file, or programmatically access one using StorageLibrary, but you're not guaranteed to have access to the returned file through its Path property (which is what the TileCache constructor takes). If your TPK file is in the app's directory, however, it's pretty easy. Here are a couple of options: Perhaps the easiest solution is to just package your TPK file(s) with the app. You can add them to your project (in the Assets folder, for example) and give them a Build Action of "Content" and set Copy to Output Directory to "Do not copy". In your app code, you can use an "ms-appx" URI to access things in your app's local folder, like so: // "Topographic.tpk" is in the application's "Assets" folder: Build action = "Content", Copy = "Do not copy"
var tpkFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri(@"ms-appx:///Assets/Topographic.tpk"));
// After opening the file from the app's Assets folder, use the path to create the tile cache
TileCache tileCache = new TileCache(tpkFile.Path);
// Load the cache using that file
// Note: this is where an exception is thrown if a file is not accessible
await tileCache.LoadAsync();
// Make a new tiled layer from the local cache
ArcGISTiledLayer localTileLayer = new ArcGISTiledLayer(tileCache);
// Add it to the map
var map = new Map();
map.Basemap.BaseLayers.Add(localTileLayer);
MyMapView.Map = map; If you still would like your user to select a TPK from their device and add it as a tile layer, you can take the extra step of copying the selected file to the app's local storage. Once there, you can create the TileCache using its Path. Here's an example: // Create a file picker to get a *.tpk file from the user
FileOpenPicker openPicker = new FileOpenPicker();
openPicker.FileTypeFilter.Add(".tpk");
openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
// Show the picker and get the selected file
StorageFile selectedFile = await openPicker.PickSingleFileAsync();
if(selectedFile == null) { return; }
// Open the selected .tpk file for read
var stream = await selectedFile.OpenReadAsync();
// Create a local copy of the tpk file; replace if exists
StorageFolder localStorage = ApplicationData.Current.LocalFolder;
StorageFile localTpkFile = await localStorage.CreateFileAsync(selectedFile.Name, CreationCollisionOption.ReplaceExisting);
// Write the contents of the selected .tpk to the new local file
var writeStream = await localTpkFile.OpenStreamForWriteAsync();
stream.AsStreamForRead().CopyTo(writeStream);
writeStream.Flush();
// ** Important to dispose ... won't be able to access the file otherwise!
writeStream.Dispose();
// Create a new TileCache with the path to the *local storage* version of the file
TileCache tileCache = new TileCache(localTpkFile.Path);
await tileCache.LoadAsync();
// Create a new tile layer from the cache and add it to the map
ArcGISTiledLayer localTileLayer = new ArcGISTiledLayer(tileCache);
var map = new Map();
map.Basemap.BaseLayers.Add(localTileLayer);
MyMapView.Map = map; I hope that helps! Thad
... View more
02-07-2017
03:38 PM
|
2
|
0
|
596
|
POST
|
Hey Paul, I tried this today and experienced the same issue you described. I took a closer look at the underlying REST request and the culprit was the value of the layers parameter, which looked like this: "[0,1,2,0,1]" (notice that layers 0 and 1 are in there twice). The following code adds to the GenerateGeodatabaseParams.LayerOptions, but those layers (and one more) are already defined by default: generateGdbParams.LayerOptions.Add(new GenerateLayerOption(marineLayerId, dolphinsOnlyWhereClause)); generateGdbParams.LayerOptions.Add(new GenerateLayerOption(birdsLayerId)); So ... you just need to clear the LayerOptions before adding to them: generateGdbParams.LayerOptions.Clear(); //<--Do this before adding to the layer options generateGdbParams.LayerOptions.Add(x); generateGdbParams.LayerOptions.Add(y); I also found another glitch "downstream" from this that you might hit. When creating the layer from one of the output GDB tables, you need to make sure you load the table first, otherwise you'll get an exception when trying to read properties (such as the Name of the table): // get the first table var gdbFeatureTable = gdb.GeodatabaseFeatureTable(0); await gdbFeatureTable.LoadAsync(); // <--Load it! // create a FeatureLayer to display the table var localGdbLayer = new FeatureLayer(gdbFeatureTable); // name the layer with the table name localGdbLayer.Name = gdbFeatureTable.TableName; //<--exception here if it's not loaded Apologies for the frustration, we certainly should have caught this before putting it in the doc. Thanks for pointing it out ... at least we can save the next person some stress! Please let us know if you hit anything else. Thad
... View more
01-12-2017
01:17 PM
|
0
|
1
|
928
|
POST
|
Thanks Dennis! I've made those fixes and should have the updates on-line soon. I've also added another (shorter!) tutorial about working with a variety of basemaps in your app ... look for that soon. You might also be interested in the series of blog posts I'm working on that steps through different facets of working with the ArcGIS platform. You'll find the first post here: Go from zero to app ... Thanks again ... feel free to pass along any other problems you find (or suggestions).
... View more
12-08-2016
02:14 PM
|
0
|
0
|
241
|
POST
|
I geeked out with this for a while. Although I still don't have an answer for you, I've found a pattern that points to different "datums" (models of the Earth's surface) being used in the conversions. If I check the converted and projected values for different input coordinates, they match for latitudes between 19.75 and 50.25 N (longitude doesn't seem to be a factor). Here's the code I tested with: double latitude = double.Parse("50.250000"); // No difference if values are between 19.75N and 50.25N
double longitude = double.Parse("-81.000000"); // 81.0W is the central meridian for UTM 17N
SpatialReference spref = new SpatialReference(26717); // NAD_1927_UTM_Zone_17N
MapPoint baseMapPoint = new MapPoint(longitude, latitude, SpatialReferences.Wgs84);
MapPoint mapPoint1 = GeometryEngine.Project(baseMapPoint, spref) as MapPoint;
MapPoint mapPoint2 = ConvertCoordinate.FromDecimalDegrees(string.Format("{0},{1}", latitude, longitude), spref);
var xDiff = Math.Abs(mapPoint2.X - mapPoint1.X);
var yDiff = Math.Abs(mapPoint2.Y - mapPoint1.Y);
// Check the difference in latitude (Y) and longitude (X)
// It is 0 when initial latitude is south of 19.75N or north of 50.25N
Debug.Print("Difference X: " + xDiff);
Debug.Print("Difference Y: " + yDiff);
... View more
08-24-2016
10:22 AM
|
0
|
0
|
1081
|
POST
|
Interesting ... I'll explore it a little further, but on the surface (no pun intended), the only thing that stands out is the fact that GeometryEngine.Project uses a map point with an explicitly defined datum (from WGS 84), while ConvertCoordinate.FromDecimalDegrees does not. I would assume that WGS 84 is used for the conversion, but maybe not (?). Maybe a different datum (surface) is being used for that conversion and that accounts for the difference. BTW - the WKID for NAD 1927 UTM 17N is 26717 (you're missing the middle "7").
... View more
08-24-2016
09:12 AM
|
0
|
0
|
1081
|
POST
|
Hi Florian - This is a known issue (originally documented for 10.2.6): a value of 'Screen' for the AngleAlignment is not honored in static rendering mode. There is a bug and an enhancement request for it: BUG-000082987, ENH-000086717. Implementing a fix has the potential to negatively impact rendering performance (which is the key feature of using static mode for rendering), so that is likely to be a driving factor for whether this is addressed or not.
... View more
08-03-2016
11:33 AM
|
0
|
0
|
171
|
Title | Kudos | Posted |
---|---|---|
1 | 03-14-2019 01:59 PM | |
1 | 10-17-2023 12:39 PM | |
1 | 10-30-2023 11:55 AM | |
1 | 10-28-2023 12:47 PM | |
2 | 10-28-2023 11:56 AM |
Online Status |
Offline
|
Date Last Visited |
yesterday
|