The Topobase Insiders

Flatten the Utility Model

A number of Topobase verticals use the utility model which separates geometry from attribute feature classes. Although the utility model provides many advantages, such as soft splits, one of the disadvantages is that symbolization on a map is difficult since the geometry to draw is not available directly from the attribute features. There are a couple of workarounds, but what is proposed here is to create one database view for each attributive feature class that joins the geometry features with the attributive features.

Compared to other alternatives, there is a performance hit because of more layers, but this overhead becomes less significant with larger data sets. The advantage is that all attributes are available to symbolize with, which is difficult to achieve with union views. With the code supplied below it's also easy to do.

The supplied administrator plugin provides a button on an admin page called Flatten. Pushing the button creates a view for each attributive class in each utility model. The view for a point type of feature classes always has the following form:

create or replace view v_wa_valve (FID, GEOM, ORIENTATION, Z, QUALITY,
    FID_SITE, CADASTRAL_INFO, ...  VALVE_LENGTH) as
select
  g.fid,
  g.geom,
  g.orientation,
  g.z,
  g.quality,
  g.fid_site,
  a.cadastral_info,
...
  a.valve_length
from wa_point g, wa_valve a
where g.fid_attr = a.fid;

The items in blue come from the geometry class and the green items come from the attribute class (only a few are shown). The name of the view is the same as the attributive class with a "V_" prefix to indicate it is a view. The caption is also given a "View " prefix. There is a similar form for linestring type classes. After executing the view creation SQL, the view is registered as a feature class. The topic for these views is given a " Views" suffix. Various housekeeping chores such as registering the view in user_sdo_geom_metadata are handled automatically.

To use the plugin, copy the .DLL and .TBP file to the Topobase Administrator bin\ directory. Start the administrator and select the Flatten tab. Push the Flatten button. If you don't like it you can push the Unflatten button to drop the feature class references, views and topics that were created.

AUTODESK DOES NOT GUARANTEE THAT YOU WILL BE ABLE TO SUCCESSFULLY DOWNLOAD OR IMPLEMENT ANY SAMPLE CODE. SAMPLE CODE IS SUBJECT TO CHANGE WITHOUT NOTICE TO YOU. AUTODESK PROVIDES SAMPLE CODE "AS IS" WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL AUTODESK OR ITS SUPPLIERS BE LIABLE FOR ANY DAMAGES WHATSOEVER INCLUDING DIRECT, INDIRECT, INCIDENTAL, CONSEQUENTIAL, LOSS OF DATA, OR LOSS OF BUSINESS PROFITS OR SPECIAL DAMAGES, THAT MAY OCCUR AS A RESULT OF IMPLEMENTING OR USING ANY SAMPLE CODE, EVEN IF AUTODESK OR ITS SUPPLIERS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

Download FlattenPlugIn

Enhanced Stylization - Flow Direction

Following on from the post on Enhanced Stylization on the Geospatial Navigator blog, I would like to illustrate how to add flow direction to linestyles.

We'll start by adding a layer with enhanced stylization for a linestring feature class as shown in the Annotation Layers post.

Double-click the layer in the Display Manager and select the ellipse button (...) in the Feature Label column. In the Style and Label Editor dialog select the Feature Symbol Label tab. Add a symbol by clicking the green plus sign. This generates a default square symbol. Set the colors and sizes to your liking, and click OK and Apply, and exit the style editor. Save the layer by right-clicking the layer in the Display Manager and choosing Save Layer....

Edit the layer file with your favorite text editor (one that understands XML if possible) and find the SymbolInstance for the square.

<SymbolInstance>
 <SimpleSymbolDefinition>
  <Name>Square</Name>
  <Description>Default Point Symbol</Description>
  <Graphics>
   <Path>
    <Geometry>M -1.0,-1.0 L 1.0,-1.0 L 1.0,1.0 L -1.0,1.0 L -1.0,-1.0</Geometry>
    <FillColor>%FILLCOLOR%</FillColor>
    <LineColor>%LINECOLOR%</LineColor>
    <LineWeight>%LINEWEIGHT%</LineWeight>
   </Path>
  </Graphics>
  <LineUsage>
   <AngleControl>FromAngle</AngleControl>
   <Angle>%ROTATION%</Angle>
   <Repeat>1.0</Repeat>
  </LineUsage>

The geometry encoding is described in various documents on Advanced Stylization available at the OsGeo site, but it's pretty simple. For the default square symbol, this is M -1.0,-1.0 L 1.0,-1.0 L 1.0,1.0 L -1.0,1.0 L -1.0,-1.0. The interpretation of this sequence is shown in the figure. Basically it says Move to the lower left corner, then draw Lines around a square in the Cartesian plane.

Replace the Geometry contents with an arrow shape such as, M -1.0,-1.0 L -1.0,1.0 L 1.0,0.0 L -1.0,-1.0. This says Move to the lower left corner and draw Lines in a triangle shape with the point to the right. The last L -1.0,-1.0 could be replaced by Z which draws a closing line to the starting point. If you change the size of the symbol, another element to play with is the Repeat interval which indicates how often the symbol should be repeated along the line.

Change the AngleControl to be FromGeometry instead of FromAngle, which makes the base angle for the rotation expression aligned with the geometry of the line instead of absolute zero degrees (east). You can optionally change all references to the name Square into something like Arrow and the description to something more appropriate, but this isn't required. Save the file.

Back in the Topobase Client, you can remove the original layer and drag your edited layer file onto the Display Manager. You should see the same stylization as before, but the squares will now be your triangle symbols aligned with the linestrings they lie on.

Now for the magic. Return to the Feature Symbol Label tab of the Style and Label Editor dialog. Cick the Expression button next to the Rotation parameter and enter an expression that evaluates to zero for forward flow linestrings and 180 for reverse direction flow. You can use If, Lookup or NullValue for example, which are found under the Conversion button. The general form of the IF expression is If ([condition], [trueValue], [falseValue]). In this example the condition is setup to compare the value of the UTILITY_INFO attribute to 1. If it is equal to 1 the true expression is used (180.0). Otherwise the false expression is used (0.0), see the screenshot. For your data model and flow attribute values, you will probably need a different expression.

As you can see, the triangles are normally aligned with the digitization direction of the linestring - zero degrees FromGeometry, but if the UTILITY_INFO attribute is set to 1, then the triangles are reversed - 180 degrees FromGeometry.

The symbol can be symbolized with color, line thickness, etc. or scaled unequally to get a pointier arrow, but if you want a two line arrow or a curved arrow head, you would need to change the geometry encoding to eliminate the line opposite the triangle tip or use curves instead of lines.

Using the Topobase Tracing API

This post was contributed by Joe Chandler.

I would like to show how you can utilize the Topobase tracing API. For this example we will be using the Topobase Batch executable to actually run the trace, but this code can be incorporated into a client plug-in just as easily.

For ease of demonstration we will be randomly selecting a couple of features from an attribute feature class specified in the Data section of the Topobase Batch XML configuration file. The XML file contains the following contents:

<?xml version="1.0" encoding="utf-8" ?>
<Batch>
  <Assembly 
    AssemblyName="TraceExample.dll" 
    Namespace="TraceExample" 
    ClassName="TraceExample"></Assembly>
  <Connection 
    Username="WATER"
    PassWord="WATER"
    Datasource="ORCL"
    tbsysUsername="TBSYS"
    tbsysPassword="TBSYS"
    tbsysDataSource="ORCL"></Connection>
  <Data 
    TopologyName="WA" 
    TestFeatureGeometryClass="WA_POINT" 
    TestFeatureClass="WA_FITTING">       
  </Data>
</Batch>

The example will create a search template and associated stop condition programmatically and use these newly created objects for the trace. We will be using an existing Topology for the example which is also specified in the Topobase Batch XML configuration file. The following image represents where predefined search templates and conditions can be found in the administrator.

This example relies on the following Topobase assemblies:

• Topobase.Batch.dll
• Topobase.Data.dll
• Topobase.LogicalTopology.dll
• Topobase.Tracing.dll

The Run() method in this example gets things started by selecting features from the specified TestFeatureClass, which in this example is the WA_FITTING feature class. It then calls the Trace method with a start feature and an end feature. In this example the end feature will be used as a stop condition for a Reachability network trace type. The second call to the Trace method is passing null as the end feature which will let the tracing run without a trace stop condition.

public override void Run()
{
    Topobase.Data.FeatureClass attributeFeatureClass =
       _connection.FeatureClasses[_testFeatureClass];
    if (attributeFeatureClass == null || !attributeFeatureClass.IsAttributeTable)
    {
        _logger.ErrorFormat("Invalid example feature class {0}. " +
            "It must be a valid attribute feature class.", _testFeatureClass);
        return;
    }
    Topobase.Data.FeatureList allFeatures = attributeFeatureClass.GetFeatures();
    if (allFeatures.Count <= 2)
    {
        _logger.ErrorFormat("Not enough features in class {0} for the example to run.",
            _testFeatureClass);
        return;
    }

    //made it here - now lets do some example tracing
    Trace(_topology, allFeatures[0], allFeatures[2]);
    Trace(_topology, allFeatures[0], null);
} 

The following section is the tracing code itself. Below are a few items to note about the API usage:

1. The LogicalTracing instance that is created will use a specific tracing algorithm based on the tracing type specified in the NetworkSearchTemplate instance. Care should be taken when calling the LogicalTracing.Trace(…) method as not all tracing algorithms take start and end features. For example, with the Reachability algorithm, end features cannot be specified. If they are, an exception will be thrown.
2. The features passed as start and end features should not be attribute features. This example is specifically demonstrating that the geometry feature instance must be retrieved and passed to the LogicalTracing.Trace(…) method if dealing with attribute feature classes.
3. There is a convenience method that can be used to take the TracingResult and convert it into an IList instance.

private void Trace(string topologyName, Topobase.Data.Feature startFeature,
    Topobase.Data.Feature endFeature)
{
    //setup the topology and the search template to be used
    Topobase.Data.Doc.Topologies.LogicalTopology logicalTopology =
        (Topobase.Data.Doc.Topologies.LogicalTopology)_connection.Topologies[topologyName];
    Topobase.Data.Doc.Topologies.NetworkSearchTemplate theSearchTemplate =
        CreateReachabilityTemplate(endFeature);

    //we need to use the fid of the geometry class and not the attribute class
    //This is done for both the start and the end features.
    Topobase.Data.FeatureClass pointFeatureClass =
        _connection.FeatureClasses[_geometryFeatureClass];
    Topobase.Data.FeatureList startFeatures = pointFeatureClass.GetFeatures("FID_ATTR = "
        + startFeature.FID);
    Topobase.Data.FeatureList endFeatures = null;
    if (endFeature != null)
        endFeatures = pointFeatureClass.GetFeatures("FID_ATTR = " + endFeature.FID);

    //Create the tracer instance and perform the trace
    Topobase.LogicalTopology.Tracing.LogicalTracing tracer =
        new Topobase.LogicalTopology.Tracing.LogicalTracing(
            logicalTopology, theSearchTemplate);
    Topobase.Tracing.TracingResult ret = null;
    bool b = tracer.Trace(startFeatures, null, out ret);

    //get the results as features
    //and possibly do something with the results here - 
    //maybe store them in a table for reporting OR
    //store them in a table to be displayed by another system as a layer with FDO
    IList tracerResultFeatures = tracer.ConvertTracingResult(ret);
    _logger.Info("The total number of trace results: " + tracerResultFeatures.Count);
}

This last code snippet is showing how to create a NetworkSearchTemplate instance with a stop condition, if a valid end feature is specified. The following are a few items to note about the API usage:

1. With the Reachability trace type end features cannot be passed as parameters to the trace method so a stop condition can be used to terminate the trace if desired.
2. You can use the preconfigured tracing templates, but care should be taken when adding stop conditions to the template as they will be added in the database. If your code dynamically needs to add stop conditions this could potentially interfere with other tracing operations being performed if the conditions are not removed after the trace.

private Topobase.Data.Doc.Topologies.NetworkSearchTemplate CreateReachabilityTemplate(
    Topobase.Data.Feature stopConditionFeature)
{
    Topobase.Data.Doc.Topologies.NetworkSearchTemplate theSearchTemplate =
        new Topobase.Data.Doc.Topologies.NetworkSearchTemplate();
    theSearchTemplate.Name = "Trace Example Template";
    theSearchTemplate.Type =
        Topobase.Data.Doc.Topologies.NetworkSearchTemplate.TraceType.Reachability;
    theSearchTemplate.Direction =
        Topobase.Data.Doc.Topologies.NetworkSearchTemplate.TraceDirection.Both;
    if (stopConditionFeature != null)
    {
        Topobase.Data.Doc.Topologies.NetworkSearchCondition myCondition =
            new Topobase.Data.Doc.Topologies.NetworkSearchCondition();
        myCondition.Active = true;
        myCondition.IsCost = false;
        myCondition.Name = "Trace Example - Generated";
        myCondition.Type =
            Topobase.Data.Doc.Topologies.NetworkSearchCondition.ConditionType.NodeCondition;
        Topobase.Data.FeatureClass pointFeatureClass =
            _connection.FeatureClasses[_geometryFeatureClass];
        myCondition.SqlStatement = "case /* Point */ when &f_class_id = "
            + pointFeatureClass.ID + " then (select case when f_class_id_attr = "
            + stopConditionFeature.FeatureClass.ID;
        myCondition.SqlStatement += " then (select 1 from "
            + stopConditionFeature.FeatureClass.Name + " where fid=wa_point.fid_attr and fid ="
            + stopConditionFeature.FID + ") else null end from "
            + pointFeatureClass.Name + " wa_point where fid=&fid) else null end";
        if (_logger.IsDebugEnabled)
            _logger.Debug(myCondition.SqlStatement);
        Topobase.Data.Doc.Topologies.NetworkSearchTemplateCondition myTemplateCondition =
            new Topobase.Data.Doc.Topologies.NetworkSearchTemplateCondition(myCondition);
        theSearchTemplate.Conditions.Add(myTemplateCondition);
    }
    return theSearchTemplate;
}

The following image represents the trace results from within Topobase using a default tracing template with no stop conditions (7 results found):

The following are the results from the batch tracing demonstrating the use of the API. These results are taken from the Topobase Application.log.

With the stop condition: The total number of trace results: 4
Without the stop condition: The total number of trace results: 7

AUTODESK DOES NOT GUARANTEE THAT YOU WILL BE ABLE TO SUCCESSFULLY DOWNLOAD OR IMPLEMENT ANY SAMPLE CODE. SAMPLE CODE IS SUBJECT TO CHANGE WITHOUT NOTICE TO YOU. AUTODESK PROVIDES SAMPLE CODE "AS IS" WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL AUTODESK OR ITS SUPPLIERS BE LIABLE FOR ANY DAMAGES WHATSOEVER INCLUDING DIRECT, INDIRECT, INCIDENTAL, CONSEQUENTIAL, LOSS OF DATA, OR LOSS OF BUSINESS PROFITS OR SPECIAL DAMAGES, THAT MAY OCCUR AS A RESULT OF IMPLEMENTING OR USING ANY SAMPLE CODE, EVEN IF AUTODESK OR ITS SUPPLIERS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

Download TraceExample

Dimensions & Hatches

Every so often, a request surfaces to be able to convert some of the more exotic AutoCAD drawing entities into Topobase features. Out of the box, Topobase will convert standard entities like points, blocks, lines and polylines using the Create new Feature from Geometry context menu. But, there are a few standard AutoCAD entities that aren’t converted. Most requested among these are dimensions and hatches.

These are complex entities, having deep internal structure within an AutoCAD drawing, so their conversion is not straight-forward and heavily subject to interpretation. This post provides only a sample conversion for these features – but of course it includes source code, so you are free to provide your own implementation if it doesn’t fit your needs.

Dimensions

The dimension entity in AutoCAD is really just a placeholder for an anonymous block that has the actual entities you think of as a dimension. These are the dimension line, the extension lines, the arrow heads, the dimension text and (usually invisible) dimension definition or reference points at the ends of the extension lines and on the dimension line. Most of these map directly to the dimension feature classes of the Topobase Dimension extension module which are created when you add the dimension extension to a Topobase document. Of interest to this post are the Aligned Dimension, Aligned Dimension (line), Aligned Dimension (point) and Aligned Dimension (label), which is the label class for aligned dimension lines.

When a dimension is created, an Aligned Dimension feature is inserted that acts as the parent feature for all other classes. Zero or more Aligned Dimension Lines are inserted with various values of LINE_TYPE, e.g. ‘AL’ and ‘HL’, standing for abscissa line and helper line, depending on the dimensioning command used. If the lines are not supposed to be symbolized (because they are hidden) the LINE_TYPE has an underscore suffix. Two Aligned Dimension Point features are inserted at the ends of the dimension line, and these can be used to symbolize the arrowheads. The Dimension Label is inserted above the dimension line. The operation of the dimension workflows are described in the online documentation.

If one wants to convert an AutoCAD dimension, one must map the entities in the anonymous dimension block to the proper feature classes and create the right relationships; that is, it isn’t enough to explode the dimension and convert the pieces. Even if you convert all the fragments (points, lines, solids, blocks and text), and choose the right feature class for each of the fragments, the relation between them would be lost. So the supplied program converts dimensions as a gestalt – converting the geometry and properties of important fragments and establishing the correct relations between the elements.

A little guesswork is required, in the form of heuristics, but the AutoCAD associative dimensions are regular enough in internal structure to make this work – at least for HORizontal, VERtical and ALIgned dimensions in the AutoCAD sense. Other dimension types such as RADius and ANGle aren’t supported by the Topobase data model.

The conversion process operates in two phases. In the first phase the necessary features are instantiated. These are given only enough temporary geometry to correctly auto-insert the label. In the second phase, the program iterates over the anonymous dimension block entities and assigns the actual geometry and label details.

To get the same look-and-feel as AutoCAD dimensions, there must be corresponding symbology associated with the label feature classes. For example, the default AutoCAD arrow heads need a corresponding point symbolization for the Aligned Dimension (point) feature class with appropriate rotation and scaling. The label too needs symbolization to get the correct text height, rotation and – we cheat a bit here – an obscuring white background so that the dimension line appears to be broken in two by the label.

The results are shown below. I leave it up to the reader to figure out which are AutoCAD dimension entities and which are Topobase features. The display model that was used is also supplied. It contains the standard AutoCAD dimension arrowhead as an enhanced stylization symbol.

Hatches

The AutoCAD hatch command is very powerful, generating outer rings and nested holes and islands for very complex geometry with a very small amount of user input. For example, one can use a crossing window to select all the entities comprising the hatch boundaries or pick selected interior points and have AutoCAD figure it out and create the hatch in one step. To perform the same operations manually in Topobase would be tedious.

The supplied sample code converts hatches into a Polygon or MultiPolygon features. There isn’t much to describe about the procedure without delving into the math involved. Suffice it to say that it examines and copies the exterior and interior loops that define the hatch boundaries into the geometry of a polygon, making it a multi-polygon if multiple exterior loops are detected.

Sample Program

The whole program is packaged as a simple EntityConverter.dll with an exposed ConvertEntities command. It asks the user to select one or more AutoCAD entities and converts the selected dimensions and hatches (and solids and polylines just for good measure) into features. As mentioned above, the target classes for dimensions are fixed by the Dimension extension, but the target feature class for polylines and hatches are requested the first time they are needed, or can be set using the commands SelectPolyLineFeatureClass and SelectPolygonFeatureClass. It could easily be made into a workflow that allows the user to choose these and various other options that are currently hard-coded.

To run the program, you will need a document that has the Dimension extension. Copy the EntityConverter.dll into the Topobase bin directory. In Topobase Client, use the NetLoad command and choose the DLL. Create one or more hatches or dimensions using AutoCAD and then invoke the ConvertEntities command, which asks you to select the entities to be converted.

To build the program, define the environment variable TopobaseClientDirectory to be the directory where you have installed Topobase client. If you are using the Topobase 2011 Beta, you will need to change assembly references as follows:

Assembly References

TB2010 References	TB2011 References
Autodesk.Map.Platform.dll	Autodesk.Map.Platform.Core.dll
	OSGeo.MapGuide.PlatformBase.dll
	OSGeo.MapGuide.Foundation.dll

AUTODESK DOES NOT GUARANTEE THAT YOU WILL BE ABLE TO SUCCESSFULLY DOWNLOAD OR IMPLEMENT ANY SAMPLE CODE. SAMPLE CODE IS SUBJECT TO CHANGE WITHOUT NOTICE TO YOU. AUTODESK PROVIDES SAMPLE CODE "AS IS" WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL AUTODESK OR ITS SUPPLIERS BE LIABLE FOR ANY DAMAGES WHATSOEVER INCLUDING DIRECT, INDIRECT, INCIDENTAL, CONSEQUENTIAL, LOSS OF DATA, OR LOSS OF BUSINESS PROFITS OR SPECIAL DAMAGES, THAT MAY OCCUR AS A RESULT OF IMPLEMENTING OR USING ANY SAMPLE CODE, EVEN IF AUTODESK OR ITS SUPPLIERS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

Download EntityConverter