Updating geometry of existing features

In this topic

• About updating geometry of existing features
• Accessing feature geometry
• Moving features
• Moving a set of features
• Replacing features
• Modifying parts of a geometry
• Using the edit sketch
• Setting and storing geometry
• Updating and managing z-values
• Assigning z-values
• Handling invalid z-values
• Snapping using z-values

About updating geometry of existing features

• Moving whole features to a different location
• Replacing features with a new geometry
• Modifying part of an existing geometry

Accessing feature geometry

Moving features

ITransform2D trans2D = IFeature.Shape as ITransform2D;
double dx = 0;
double dy = 3;
trans2D.Move(dx, dy);
IFeature.Store();

Dim trans2D As ITransform2D = TryCast(IFeature.Shape, ITransform2D)
Dim dx As Double = 0
Dim dy As Double = 3
trans2D.Move(dx, dy)
IFeature.Store()

Moving a set of features

Replacing features

Modifying parts of a geometry

Using the edit sketch

Setting and storing geometry

Updating and managing z-values

UIDClass edUID = new UIDClass();
edUID.Value = "esriEditor.Editor";
editor = m_application.FindExtensionByCLSID(edUID)as IEditor;

IEditorZ editorZ = m_editor as IEditorZ;

Dim edID = New UID
m_editor = m_application.FindExtensionByCLSID(edID)

Dim editorZ As IEditorZ
editorZ = m_editor

Assigning z-values

• Maintain or apply existing z-values—When assigning z-values while editing, determine if it is appropriate for existing z-values to be maintained when editing a feature or creating a feature. For example, when an existing feature is rotated, scaled, spatially adjusted, or moved, or a new feature is created by copying and pasting from an existing feature, these actions are performed without adding or deleting vertices. While the x,y values can change, z-values are not changed. If a feature has existing z-values, the editor maintains them where appropriate.
• Obtain z-values by snapping to existing features—When it is not practical to use existing z-values, determine if snapping in z should occur. If there is an existing feature with z-values to snap to and it's within the z-snapping tolerance, assignment of z-values by snapping overrides other z-assignment behavior. Z-snapping requires that at least one x,y snap agent (vertex, edge, or end) be enabled for the layer. In addition, set a z-snap tolerance other than 0 (default value) for z-snapping to occur. Z-tolerance is used in conjunction with the x,y snap tolerance to describe a cylinder that determines if snap conditions are met in x,y, and z.
• Use one of three z-capture types or modes—In addition to using existing z-values and obtaining new z-values through snapping, z-assignment comes from one of the following z-capture types (also known as z-modes):
• CurrentZ (Assigning z-values based on a specific value)
With CurrentZ, vertices are assigned the current z-value as specified programmatically or in the current z-control. A CurrentZ value always exists, with 0 as the default. CurrentZ is useful when elevations are constant, such as when sketching a bridge or overpass in a road network. The bridge has a known height above the surface that is typically constant over its length.
• InterpolateZ (Assigning z-values based on interpolation or extrapolation
Interpolate mode is the second method for z-assignment, where vertices are assigned z-values interpolated (or extrapolated) from known z-values of existing features. In some cases, there are no values available to interpolate from; therefore, resulting z-values fall back to the CurrentZ value since it always exists. Interpolate mode can be useful to connect points with known x,y,z locations but lack the specific z-values between the points. Interpolate mode is also useful when reshaping existing features.
• SurfaceZ (Assigning z-values using a surface)
Surface mode is the third method, which allows vertices to be assigned z-values obtained from the cells or faces of a specified surface. The surface can be any type that implements IFuntionalSurface, including triangulated irregular networks (TINs), rasters, and terrains. When you have a relatively high-resolution surface available, surface mode is useful in most editing scenarios, such as creating features and editing existing features.

To ensure the feature fits the underlying surface more accurately, turn on draping, which automatically creates intermediate vertices at each change in elevation defined by the surface. Draping allows the segments in the sketch to more closely fit the underlying surface.

If you are capturing using an accurate surface with draping enabled to fit the feature to the underlying surface, use the DrapingTolerance to limit the number of vertices added to the edit sketch. Draping is not the same as stream mode digitizing, which also automatically adds vertices to a sketch. Draping considers the elevation differences within a segment when determining whether to create a vertex; therefore, vertices cannot be placed at an equal interval as they would be with stream mode digitizing. When z-snapping occurs, draping does not occur. Only points added through the draping process are removed as part of this process; any points explicitly added to the edit sketch are maintained.

private void SetDrapeProperties()
{
    // If the capture is surface, set up draping properties.
    if (editorZ.ZCaptureType == esriZCaptureType.esriCaptureSurfaceZ)
    {
        editorZ.Draping = true;
        editorZ.UseZDrapingTolerance = true;
        editorZ.ZDrapingTolerance = 2;
    }
}

Private Sub SetDrapeProperties()
    If editorZ.ZCaptureType = esriZCaptureType.esriCaptureSurfaceZ Then
        editorZ.Draping = True
        editorZ.UseZDrapingTolerance = True
        editorZ.ZDrapingTolerance = 2
    End If
End Sub

Handling invalid z-values

1. Checks if the geometry is z-aware. If it is not z-aware, the geometry's z-aware property is set to true.
2. Checks if any vertex's z-value is considered non-simple (that is, NaN).
3. If the geometry has a non-simple z-value and a class implementing INotifyZFinalize is registered with the editor, the geometry is passed to the class to handle the non-simple z-values.
4. The editor checks the geometry a second time for non-simple z-values.
5. If non-simple z-values are still present, IZ.CalculateNonSimpleZs is called.

Snapping using z-values

private void SetZSnapping(IEditor editor)
{
    ISnapEnvironment2 snapEnv = editor as ISnapEnvironment2;
    if (snapEnv == null)
        return ;

    // Set general snapping environment information.   
    snapEnv.UseSnapZTolerance = true;
    snapEnv.SnapZTolerance = 3;

    IFeatureSnapAgent2 featureSnap = null;
    IField field = null;
    IGeometryDef geomDef = null;
    IFeatureClass featureClass = null;

    // Iterate each feature snap agent. If the underlying feature class
    // supports z-values, enable snapping to z-values.
    for (int i = 0; i < snapEnv.SnapAgentCount; i++)
    {
        featureSnap = snapEnv.get_SnapAgent(i)as IFeatureSnapAgent2;
        if (featureSnap != null)
        {
            featureClass = featureSnap.FeatureClass;
            field = featureClass.Fields.get_Field(featureClass.FindField
                (featureClass.ShapeFieldName));
            geomDef = field.GeometryDef;
            if (geomDef.HasZ)
            {
                featureSnap.ZSnappingEnabled = true;
            }
        }
    }
}

Private Sub SetZSnapping(ByVal editor As IEditor)
    Dim snapEnv As ISnapEnvironment2 = editor As ISnapEnvironment2
    
    If snapEnv Is Nothing Then
        Return
    End If
    
    ' Set general snapping environment information.
    snapEnv.UseSnapZTolerance = True
    snapEnv.SnapZTolerance = 3
    
    Dim featureSnap As IFeatureSnapAgent2 = Nothing
    Dim field As IField = Nothing
    Dim geomDef As IGeomeTryDef = Nothing
    Dim featureClass As IFeatureClass = Nothing
    
    ' Iterate each feature snap agent. If the underlying feature class
    ' supports z-values, enable snapping to z-values.
    Dim i As Integer
    
    For i = 0 To snapEnv.SnapAgentCount - 1 Step i + 1
        
        featureSnap = snapEnv.get_SnapAgentCType(As IFeatureSnapAgent2, i)
        
        If Not featureSnap Is Nothing Then
            featureClass = featureSnap.FeatureClass
            field = featureClass.Fields.get_Field
            (featureClass.FindField(featureClass.ShapeFieldName))
            geomDef = field.GeomeTryDef
            
            If geomDef.HasZ Then
                featureSnap.ZSnappingEnabled = True
            End If
            
        End If
    Next
    
End Sub