Example #1
0
 public bool IsOverlap(SliceArea area) => Contains(area.Start) || Contains(area.End);
Example #2
0
        IEnumerable <ImagePoint> GetPoints(IEnumerable <ImagePoint> originalPoints)
        {
            IEnumerable <Slice> slices;

            if (_randomSlices)
            {
                _slicesLock.EnterReadLock();

                slices = _slices.Select(s => (Slice)s.Clone()).ToArray();

                _slicesLock.ExitReadLock();
            }
            else
            {
                slices = _slices;
            }

            Slice     slice = null;
            SliceArea area  = null;


            foreach (var point in originalPoints)
            {
                if (!(area?.Contains(point.Y) ?? false))
                {
                    area = _areas.FirstOrDefault(a => a.Contains(point.Y));
                    if (area == null)
                    {
                        yield return(point);

                        continue;
                    }
                }

                if (!(slice?.Area.Contains(point.Y) ?? false))
                {
                    slice = slices.FirstOrDefault(s => s.Area.Contains(point.Y));
                    if (slice == null)
                    {
                        yield return(point);

                        continue;
                    }
                }

                var newPoint = point.Clone();

                if (slice != null)
                {
                    switch (slice.Mode)
                    {
                    case SliceMode.Drift:
                        var vertPosInSlice = point.Y - slice.Area.Start;
                        var ypercent       = (float)vertPosInSlice / slice.Area.Height;
                        var shift          = (int)Math.Round((ypercent * slice.Drift) - (slice.Drift / 2.0));
                        newPoint.X += shift;

                        newPoint.X += slice.Shift;
                        break;

                    case SliceMode.Shift:
                        newPoint.X += slice.Shift;
                        break;
                    }
                }



                if (_settings.CarryPoints)
                {
                    // TODO: add blanking before carrying?

                    if (_maxValues.MinX > newPoint.X)
                    {
                        newPoint.X = _maxValues.MaxX - (_maxValues.MinX - newPoint.X);
                    }

                    if (newPoint.X > _maxValues.MaxX)
                    {
                        newPoint.X = _maxValues.MinX + (newPoint.X - _maxValues.MaxX);
                    }
                }
                else
                {
                    if (_maxValues.MinX > newPoint.X)
                    {
                        newPoint.X        = _maxValues.MinX;
                        newPoint.Blanking = true;
                    }

                    if (newPoint.X > _maxValues.MaxX)
                    {
                        newPoint.X        = _maxValues.MaxX;
                        newPoint.Blanking = true;
                    }
                }

                yield return(newPoint);
            } // /foreach originalPoints

            yield break;
        }