Exemplo n.º 1
0
        public void DrawImages(Graphics g)
        {
            //foreach (var obj in Circles)
            //{
            //    obj.DrawImages(g);
            //}

            for (int i = Circles.Count() - 1; i >= 0; i--)
            {
                Circles[i].DrawImages(g);
            }
        }
Exemplo n.º 2
0
        public void BeginGetAll(Func <IMarkGeometry, bool> callback)
        {
            Parallel.For(0, Points.Count(),
                         index =>
            {
                callback(Points[index]);
            }
                         );

            Parallel.For(0, Lines.Count(),
                         index =>
            {
                callback(Lines[index]);
            }
                         );

            Parallel.For(0, Arcs.Count(),
                         index =>
            {
                callback(Arcs[index]);
            }
                         );

            Parallel.For(0, Circles.Count(),
                         index =>
            {
                callback(Circles[index]);
            }
                         );

            Parallel.For(0, Paths.Count(),
                         index =>
            {
                callback(Paths[index]);
            }
                         );
        }
Exemplo n.º 3
0
        /// <summary>
        ///     Applies function to all geometries
        /// </summary>
        /// <param name="function">The function apply to all geometries</param>
        public void MapFunc(Func <IMarkGeometry, IMarkGeometry> function)
        {
            Parallel.For(0, Points.Count(),
                         index =>
            {
                Points[index] = function(Points[index]) as MarkGeometryPoint;
            }
                         );

            Parallel.For(0, Lines.Count(),
                         index =>
            {
                Lines[index] = function(Lines[index]) as MarkGeometryLine;
            }
                         );

            Parallel.For(0, Arcs.Count(),
                         index =>
            {
                Arcs[index] = function(Arcs[index]) as MarkGeometryArc;
            }
                         );

            Parallel.For(0, Circles.Count(),
                         index =>
            {
                Circles[index] = function(Circles[index]) as MarkGeometryCircle;
            }
                         );

            Parallel.For(0, Paths.Count(),
                         index =>
            {
                Paths[index] = function(Paths[index]) as MarkGeometryPath;
            }
                         );
        }
Exemplo n.º 4
0
        public override void SetExtents()
        {
            Extents.MinX = double.MaxValue;
            Extents.MaxX = double.MinValue;

            Extents.MinY = double.MaxValue;
            Extents.MaxY = double.MinValue;

            Extents.MinZ = double.MaxValue;
            Extents.MaxZ = double.MinValue;

            int[] ns =
            {
                Points.Count(),
                Arcs.Count(),
                Circles.Count(),
                Lines.Count(),
                Paths.Count()
            };

            int n = GeometricArithmeticModule.Max <int>(ns);

            for (int i = 0; i < n; i++)
            {
                if (i < Points.Count())
                {
                    Extents.MaxX = Math.Max(Extents.MaxX, Points[i].Extents.MaxX);
                    Extents.MaxY = Math.Max(Extents.MaxY, Points[i].Extents.MaxY);
                    Extents.MaxZ = Math.Max(Extents.MaxZ, Points[i].Extents.MaxZ);

                    Extents.MinX = Math.Min(Extents.MinX, Points[i].Extents.MinX);
                    Extents.MinY = Math.Min(Extents.MinY, Points[i].Extents.MinY);
                    Extents.MinZ = Math.Min(Extents.MinZ, Points[i].Extents.MinZ);
                }

                if (i < Arcs.Count())
                {
                    Extents.MaxX = Math.Max(Extents.MaxX, Arcs[i].Extents.MaxX);
                    Extents.MaxY = Math.Max(Extents.MaxY, Arcs[i].Extents.MaxY);
                    Extents.MaxZ = Math.Max(Extents.MaxZ, Arcs[i].Extents.MaxZ);

                    Extents.MinX = Math.Min(Extents.MinX, Arcs[i].Extents.MinX);
                    Extents.MinY = Math.Min(Extents.MinY, Arcs[i].Extents.MinY);
                    Extents.MinZ = Math.Min(Extents.MinZ, Arcs[i].Extents.MinZ);
                }

                if (i < Circles.Count())
                {
                    Extents.MaxX = Math.Max(Extents.MaxX, Circles[i].Extents.MaxX);
                    Extents.MaxY = Math.Max(Extents.MaxY, Circles[i].Extents.MaxY);
                    Extents.MaxZ = Math.Max(Extents.MaxZ, Circles[i].Extents.MaxZ);

                    Extents.MinX = Math.Min(Extents.MinX, Circles[i].Extents.MinX);
                    Extents.MinY = Math.Min(Extents.MinY, Circles[i].Extents.MinY);
                    Extents.MinZ = Math.Min(Extents.MinZ, Circles[i].Extents.MinZ);
                }

                if (i < Lines.Count())
                {
                    Extents.MaxX = Math.Max(Extents.MaxX, Lines[i].Extents.MaxX);
                    Extents.MaxY = Math.Max(Extents.MaxY, Lines[i].Extents.MaxY);
                    Extents.MaxZ = Math.Max(Extents.MaxZ, Lines[i].Extents.MaxZ);

                    Extents.MinX = Math.Min(Extents.MinX, Lines[i].Extents.MinX);
                    Extents.MinY = Math.Min(Extents.MinY, Lines[i].Extents.MinY);
                    Extents.MinZ = Math.Min(Extents.MinZ, Lines[i].Extents.MinZ);
                }

                if (i < Paths.Count())
                {
                    Extents.MaxX = Math.Max(Extents.MaxX, Paths[i].Extents.MaxX);
                    Extents.MaxY = Math.Max(Extents.MaxY, Paths[i].Extents.MaxY);
                    Extents.MaxZ = Math.Max(Extents.MaxZ, Paths[i].Extents.MaxZ);

                    Extents.MinX = Math.Min(Extents.MinX, Paths[i].Extents.MinX);
                    Extents.MinY = Math.Min(Extents.MinY, Paths[i].Extents.MinY);
                    Extents.MinZ = Math.Min(Extents.MinZ, Paths[i].Extents.MinZ);
                }
            }

            GridWidth  = Extents.MaxX - Extents.MinX;
            GridHeight = Extents.MaxY - Extents.MinY;
            GridDepth  = Extents.MaxZ - Extents.MinZ;

            Origin = new MarkGeometryPoint(
                Extents.MinX + (0.5 * GridWidth),
                Extents.MinY + (0.5 * GridHeight),
                Extents.MinZ + (0.5 * GridDepth)
                );
        }