Attribute Rule for Polygon Movement with Intersecting Feature Constraints

StefanAngerer

Hey fellow-esris,

I hope all is well with you. I've been working on a project and I'm trying to set up an attribute rule (constraint) for a polygon feature class that would only allow the polygon to be moved if all intersecting features are moved with it. But I'm a bit stuck and could use some help. This is the code I got so far: 

var targetAssemblyNumbers = '(2, 3, 900)'; // Assemblies which must be within stationboundaries
var targetDeviceNumbers = '(1, 2, 4, 6, 19)'; // Devices which must be within stationboundaries
var targetJunctionNumbers = '(5,50,950)'; // Junctions which must be within stationboundaries

var assemblies = FeatureSetByName($datastore, 'PipelineAssembly', ['globalid'], true)
var devices = FeatureSetByName($datastore, 'PipelineDevice', ['globalid'], true)
var junctions = FeatureSetByName($datastore, 'PipelineJunction', ['globalid'], true)

var targetAssemblies = Filter(assemblies, Concatenate(['ASSETGROUP', 'IN', targetAssemblyNumbers], ' '))
var targetDevices = Filter(devices, Concatenate(['ASSETGROUP', 'in', targetDeviceNumbers], ' '))
var targetJunctions = Filter(junctions, Concatenate(['ASSETGROUP', 'in', targetJunctionNumbers], ' '))

var preCounter = 0

preCounter += count(Intersects(targetAssemblies, Geometry($originalFeature)))
preCounter += count(Intersects(targetDevices, Geometry($originalFeature)))
preCounter += count(Intersects(targetJunctions, Geometry($originalFeature)))

var postCounter = 0

postCounter += count(Intersects(targetAssemblies, Geometry($feature)))
postCounter += count(Intersects(targetDevices, Geometry($feature)))
postCounter += count(Intersects(targetJunctions, Geometry($feature)))

if(preCounter != postCounter){
return false;
} else return true;

Any ideas or tips would be greatly appreciated.

Thanks in advance, Stefan

JohannesLindner

I believe that you can't accomplish this with a Constraint rule. The problem is that you have to know the old and new positions not only of the $feature, but of the intersecting features as well. AFAIK, there's no way to get the old geomtries of the intersecting features.

 

I would do this with a Calculation Rule instead. In Calculation rules, you can leave the field empty and return a dictionary. With this dictionary, you can declare edits to be made to other tables. For a documentation of this dictionary, see here: Attribute rule dictionary keywords—ArcGIS Pro | Documentation

 

Other things:

• If the geometry isn't changed, there is no need to load all those featuresets. Abort early.
• Instead of writing the same code for multiple featuresets, use a for loop.

// Calculation Attribute Rule on the poylgon FC
// field: empty!
// triggers: Update
// Exclude from Application Evaluation

var old_geo = Geometry($originalfeature)
var new_geo = Geometry($feature)
// if the geometry didn't change, we don't need to update the points
if(Equals(old_geo, new_geo)) { return }
// if the geometry changed, but it wasn't a simple move (eg you edited some vertices), we can't update the points
if(Area(old_geo) - Area(new_geo) > 0.0001) { return }

// calculate the coordinate change
var old_centroid = Centroid(old_geo)
var new_centroid = Centroid(new_geo)
var dx = new_centroid.x - old_centroid.x
var dy = new_centroid.y - old_centroid.y

// load and filter the associated point fcs
// the dictionary keys have to be the classnames!
var fcs = {
    "TestPoints": Filter(FeaturesetByName($datastore, "TestPoints", ["ObjectID"], true), "IntegerField IN (1, 2, 3)"),
    "Stations": Filter(FeaturesetByName($datastore, "Stations", ["ObjectID"], true), "TextField IN ('a', 'b', 'c')"),
}

// loop over the associated fcs
var edits = []
for(var fc_name in fcs) {
    var fc = fcs[fc_name]
    // create the update array
    Push(edits, {className: fc_name, updates: []})
    // get the points that intersected the $originalfeature
    var i_fc = Intersects(fc, old_geo)
    // loop over those points
    for(var f in i_fc) {
        // calculate the new point geometry
        var f_geo = Geometry(f)
        var new_x = f_geo.x + dx
        var new_y = f_geo.y + dy
        var new_f_geo = Point({x: new_x, y: new_y, spatialReference: f_geo.spatialReference})
        // append that new geometry to the update array
        Push(edits[-1].updates, {objectID: f.ObjectID, geometry: new_f_geo})
    }
}
// return the edits
return {edit: edits}

 

All you have to do is move the polygon, the rule will move the associated points for you.