예제 #1
0
 public CreateAnnoMasksEngine(CreateAnnoMasks config, IProcessingContext context,
                              IProcessingFeedback feedback)
     : base(config.Name, context, feedback)
 {
     _inputDataset      = OpenRequiredDataset(config.InputDataset, nameof(config.InputDataset));
     _outputMaskDataset = OpenRequiredDataset(config.OutputMaskDataset, nameof(config.OutputMaskDataset));
     _relationshipClass = OpenAssociation(config.OutputAssociation);
     _maskAttributes    = ProcessingUtils.CreateFieldSetter(
         config.MaskAttributes, _outputMaskDataset.FeatureClass, nameof(config.MaskAttributes));
     _maskMargin                = ImplicitValue.Create(config.MaskMargin, nameof(config.MaskMargin));
     _maskMargin.Environment    = new StandardEnvironment().RegisterConversionFunctions();
     _simplificationToleranceMu = config.SimplificationTolerance;                 // TODO convert mm to mu
     _maskOutlineType           = config.MaskOutlineType;
     _fillHoles = config.FillHoles;
 }
예제 #2
0
            public AlignMarkersEngine(AlignMarkers config, IProcessingContext context, IProcessingFeedback feedback)
                : base(config.Name, context, feedback)
            {
                _inputDataset =
                    OpenRequiredDataset(config.InputDataset, nameof(config.InputDataset));

                _referenceDatasets = OpenDatasets(config.ReferenceDatasets);

                _searchDistance = ProcessingUtils.Clip(
                    config.SearchDistance, 0, double.MaxValue,
                    nameof(config.SearchDistance));

                _markerFieldSetter = ProcessingUtils.CreateFieldSetter(
                    config.MarkerAttributes, _inputDataset.FeatureClass,
                    nameof(config.MarkerAttributes));
            }
예제 #3
0
        /// <remarks>Caller's duty to dispose features! (See Pro SDK documentation)</remarks>
        public IEnumerable <Feature> GetOtherFeatures(ProcessingDataset dataset,
                                                      Geometry extent = null,
                                                      bool recycling  = false)
        {
            var filter = ProcessingUtils.CreateFilter(dataset.WhereClause, extent);

            using (var cursor = dataset.FeatureClass.Search(filter, recycling))
            {
                while (cursor.MoveNext())
                {
                    if (cursor.Current is Feature feature)
                    {
                        yield return(feature);
                    }
                }
            }
        }
예제 #4
0
        public int CountInputFeatures(ProcessingDataset dataset, Geometry extent = null)
        {
            if (SelectionType.IsWithinEditPerimeter())
            {
                var perimeter = GetProcessingPerimeter();
                extent = GeometryUtils.Intersection(extent, perimeter);
            }

            if (SelectionType.IsSelectedFeatures())
            {
                if (dataset.Selection.SelectionCount < 1)
                {
                    return(0);
                }
                var filter = ProcessingUtils.CreateFilter(dataset.WhereClause, extent);
                return(dataset.Selection.CountSelection(filter));
            }

            return(CountOtherFeatures(dataset, extent));
        }
예제 #5
0
        /// <remarks>Caller's duty to dispose features! (See Pro SDK documentation)</remarks>
        public IEnumerable <Feature> GetInputFeatures(ProcessingDataset dataset,
                                                      Geometry extent = null,
                                                      bool recycling  = false)
        {
            if (SelectionType.IsWithinEditPerimeter())
            {
                var perimeter = GetProcessingPerimeter();
                extent = GeometryUtils.Intersection(extent, perimeter);
            }

            if (SelectionType.IsSelectedFeatures())
            {
                if (dataset.Selection.SelectionCount < 1)
                {
                    return(Enumerable.Empty <Feature>());
                }

                var filter = ProcessingUtils.CreateFilter(dataset.WhereClause, extent);
                return(dataset.Selection.SearchSelection(filter, recycling));
            }

            return(GetOtherFeatures(dataset, extent, recycling));
        }
예제 #6
0
            public CalculateControlPointsEngine(CalculateControlPoints config,
                                                IProcessingContext context,
                                                IProcessingFeedback feedback)
                : base(config.Name, context, feedback)
            {
                _inputDataset =
                    OpenRequiredDataset(config.InputDataset, nameof(config.InputDataset));

                _maximumAngle = config.MaximumAngle;

                if (!(0 <= _maximumAngle && _maximumAngle <= 180))
                {
                    throw ConfigError(
                              $"{nameof(config.MaximumAngle)} is {config.MaximumAngle}, not between 0 and 180");
                }

                _controlPointIdValue = ProcessingUtils.Clip(
                    config.ControlPointIdValue, 1, int.MaxValue,
                    nameof(config.ControlPointIdValue));

                _simplificationTolerance = ProcessingUtils.Clip(
                    config.SimplificationTolerance, 0, double.MaxValue,
                    nameof(config.SimplificationTolerance));                     // TODO convert Millimeters (Points) to MapUnits -- how?
            }
예제 #7
0
 protected int CountOtherFeatures(ProcessingDataset dataset, Geometry extent = null)
 {
     return(Context.CountOtherFeatures(dataset, extent));
 }
예제 #8
0
 protected IEnumerable <Feature> GetOtherFeatures(ProcessingDataset dataset,
                                                  Geometry extent = null,
                                                  bool recycling  = false)
 {
     return(Context.GetOtherFeatures(dataset, extent, recycling));
 }
예제 #9
0
        public int CountOtherFeatures(ProcessingDataset dataset, Geometry extent = null)
        {
            QueryFilter filter = ProcessingUtils.CreateFilter(dataset.WhereClause, extent);

            return(dataset.FeatureClass.GetCount(filter));
        }