public void RealizaTeste(List<BoundingVolume> boundingVolumes)
        {
            PRN = new List<PreRedeNeural> ();

            for (int i = 0; i < boundingVolumes.Count; i++)
            {
                if (tipo.AaA){

                    BoundingVolume c1 = boundingVolumes [i];
                    List<Vector> pontos = new List<Vector> ();
                    int nome2 = 0;
                    for (int j = 0; j < boundingVolumes.Count; j++) {
                        if (i != j) {
                            pontos.AddRange (boundingVolumes [j].Pontos.ToArray ());
                            nome2 += Convert.ToInt32 (Math.Pow (2,i));
                        }
                    }
                    BoundingVolume c2 = new OBB (pontos, nome2, boundingVolumes [i].nivel);

                    if (tipo.BV == 2){

                    }
                    if (tipo.BV == 1){
                        //caixas.Add(new AABB(dadosTreino[i], "-" + i.ToString() + "-",0));
                    }
                    if (tipo.BV == 0){
                        c2 = new Sphere (pontos, nome2, boundingVolumes [i].nivel);
                    }

                    //encontra todos os planos
                    List<Plano> planos = testeColisao (c1, c2);

                    //seleciona os melhores planos
                    planos = SelecionaPlanos (c1, c2, planos);

                    //gera a pré-rede neural
                    PreRedeNeural p = GeraPreRedeNeural (c1, c2, planos);

                    PRN.Add (p);
                }
                else
                {
                    BoundingVolume c1 = boundingVolumes [i];
                    for (int j=i+1; j<boundingVolumes.Count; j++) {
                        //encontra os planos
                        BoundingVolume c2 = boundingVolumes [j];
                        List<Plano> planos = testeColisao (c1, c2);

                        //seleciona os melhores planos
                        planos = SelecionaPlanos (c1, c2, planos);

                        //gera a pré-rede neural
                        PreRedeNeural p = GeraPreRedeNeural (c1, c2, planos);

                        PRN.Add (p);
                    }
                }
                 Console.WriteLine(" + - RN " + i.ToString() + " gerada.");
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="SphereObject"/> class.
 /// </summary>
 /// <param name="pos">The pos.</param>
 /// <param name="raio">The raio.</param>
 /// <param name="mass">The mass.</param>
 /// <param name="scale">The scale.</param>
 /// <param name="materialDescription">The material description.</param>
 public SphereObject(Vector3 pos, float raio, float mass = 10,float scale = 1,MaterialDescription materialDescription = null)
     : base(materialDescription,mass)
 {
 
     this.scale = new Vector3(scale);
     entity = new Sphere(pos, raio * scale, mass);            
 }

        /// <summary>
        /// Constructs a new demo.
        /// </summary>
        /// <param name="game">Game owning this demo.</param>
        public PlanetDemo(DemosGame game)
            : base(game)
        {
            Space.ForceUpdater.Gravity = Vector3.Zero;

            //By pre-allocating a bunch of box-box pair handlers, the simulation will avoid having to allocate new ones at runtime.
            NarrowPhaseHelper.Factories.BoxBox.EnsureCount(1000);

            var planet = new Sphere(new Vector3(0, 0, 0), 30);
            Space.Add(planet);

            var field = new GravitationalField(new InfiniteForceFieldShape(), planet.Position, 66730 / 2f, 100);
            Space.Add(field);

            //Drop the "meteorites" on the planet.
            Entity toAdd;
            int numColumns = 10;
            int numRows = 10;
            int numHigh = 10;
            float separation = 5;
            for (int i = 0; i < numRows; i++)
                for (int j = 0; j < numColumns; j++)
                    for (int k = 0; k < numHigh; k++)
                    {
                        toAdd = new Box(new Vector3(separation * i - numRows * separation / 2, 40 + k * separation, separation * j - numColumns * separation / 2), 1f, 1f, 1f, 5);
                        toAdd.LinearVelocity = new Vector3(30, 0, 0);
                        toAdd.LinearDamping = 0;
                        toAdd.AngularDamping = 0;
                        Space.Add(toAdd);
                    }
            game.Camera.Position = new Vector3(0, 0, 150);
        }

    public static Result ModifyObjectColor(RhinoDoc doc)
    {
        ObjRef obj_ref;
        var rc = RhinoGet.GetOneObject("Select object", false, ObjectType.AnyObject, out obj_ref);
        if (rc != Result.Success)
          return rc;
        var rhino_object = obj_ref.Object();
        var color = rhino_object.Attributes.ObjectColor;
        bool b = Rhino.UI.Dialogs.ShowColorDialog(ref color);
        if (!b) return Result.Cancel;

        rhino_object.Attributes.ObjectColor = color;
        rhino_object.Attributes.ColorSource = ObjectColorSource.ColorFromObject;
        rhino_object.CommitChanges();

        // an object's color attributes can also be specified
        // when the object is added to Rhino
        var sphere = new Sphere(Point3d.Origin, 5.0);
        var attributes = new ObjectAttributes();
        attributes.ObjectColor = Color.CadetBlue;
        attributes.ColorSource = ObjectColorSource.ColorFromObject;
        doc.Objects.AddSphere(sphere, attributes);

        doc.Views.Redraw();
        return Result.Success;
    }

 public void Sphere_Constructor_saves_radius()
 {
     var centre = new Point(50.0f, -12.0f, 4.2f);
     var radius = 12.2f;
     var s = new Sphere(centre, radius);
     Assert.AreEqual(radius, s.Radius);
 }

        /// <summary>
        /// Constructs a new demo.
        /// </summary>
        /// <param name="game">Game owning this demo.</param>
        public BroadPhaseDemo(DemosGame game)
            : base(game)
        {
            //Make a fatter kapow sphere.
            Space.Remove(kapow);
            kapow = new Sphere(new Vector3(11000, 0, 0), 1.5f, 1000);
            Space.Add(kapow);
            Space.Solver.IterationLimit = 1; //Essentially no sustained contacts, so don't need to worry about accuracy.
            Space.ForceUpdater.Gravity = Vector3.Zero;

            int numColumns = 15;
            int numRows = 15;
            int numHigh = 15;
            float separation = 3;

            Entity toAdd;

            for (int i = 0; i < numRows; i++)
                for (int j = 0; j < numColumns; j++)
                    for (int k = 0; k < numHigh; k++)
                    {
                        toAdd = new Box(new Vector3(separation * i, k * separation, separation * j), 1, 1, 1, 1);
                        toAdd.Material.Bounciness = 1; //Superbouncy boxes help propagate shock waves.
                        toAdd.LinearDamping = 0f;
                        toAdd.AngularDamping = 0f;
                        Space.Add(toAdd);
                    }

            game.Camera.Position = new Vector3(0, 3, -10);
            game.Camera.ViewDirection = new Vector3(0, 0, 1);
        }

        public Window()
            : base(640, 480, GraphicsMode.Default, "XSharp")
        {
            GL.Enable(EnableCap.DepthTest);

            ISharpShape shape = new Sphere().Subsect(new Vector(0.5, 0.5, 0.5), new Vector(0.5, 0.5, 0.5));
            this.Tree = OctoTree.Create(shape, 5);

            PointCloud.Point[] points = new PointCloud.Point[80000];
            for (int t = 0; t < points.Length; t++)
            {
                double ang = (double)t / (double)points.Length * Math.PI * 2.0;
                double elv = (double)Math.Sin(ang * 100.0);
                double x = (double)Math.Sin(ang);
                double z = (double)Math.Cos(ang);
                points[t] = new PointCloud.Point()
                {
                    Position = new Vector(x, z, elv),
                    A = 255,
                    R = 0,
                    G = 255,
                    B = 0
                };
            }

            this.MyPointCloud = new PointCloud();
            this.MyPointCloud.Submit(points, 2.0f);
        }

 public TestableInput(TestableGameObject obj, IInput input,
                      Sphere sphere)
     : base(obj)
 {
     this.sphere = sphere;
     this.input = input;
 }

        public static void Run()
        {
            // Initialize scene object
            Scene scene = new Scene();

            // Initialize Node class object
            Node cubeNode = new Node("sphere");

            // ExStart:ConvertSpherePrimitivetoMesh
            // Initialize object by Sphere class
            IMeshConvertible convertible = new Sphere();
            
            // Convert a Sphere to Mesh
            Mesh mesh = convertible.ToMesh();
            // ExEnd:ConvertSpherePrimitivetoMesh

            // Point node to the Mesh geometry
            cubeNode.Entity = mesh;

            // Add Node to a scene
            scene.RootNode.ChildNodes.Add(cubeNode);

            // The path to the documents directory.
            string MyDir = RunExamples.GetDataDir() + RunExamples.GetOutputFilePath("SphereToMeshScene.fbx");

            // Save 3D scene in the supported file formats
            scene.Save(MyDir, FileFormat.FBX7400ASCII);

            Console.WriteLine("\n Converted the primitive Sphere to a mesh successfully.\nFile saved at " + MyDir);
        }

 public void SetCollision()
 {
     MotionState motionState = new MotionState();
     motionState.Position = Position;
     motionState.Orientation = Quaternion.Identity;
     Entity = new Sphere(motionState, radius, mass);
 }

        /// <summary>
        /// Constructs a new demo.
        /// </summary>
        /// <param name="game">Game owning this demo.</param>
        public IncomingDemo(DemosGame game)
            : base(game)
        {
            Entity toAdd;
            //Build the stack...
            for (int k = 1; k <= 12; k++)
            {
                if (k % 2 == 1)
                {
                    toAdd = new Box(new Vector3(-3, k, 0), 1, 1, 7, 10);
                    Space.Add(toAdd);
                    toAdd = new Box(new Vector3(3, k, 0), 1, 1, 7, 10);
                    Space.Add(toAdd);
                }
                else
                {
                    toAdd = new Box(new Vector3(0, k, -3), 7, 1, 1, 10);
                    Space.Add(toAdd);
                    toAdd = new Box(new Vector3(0, k, 3), 7, 1, 1, 10);
                    Space.Add(toAdd);
                }
            }
            //And then smash it!
            toAdd = new Sphere(new Vector3(0, 150, 0), 3, 100);

            Space.Add(toAdd);
            Space.Add(new Box(new Vector3(0, 0, 0), 10, 1f, 10));
            game.Camera.Position = new Vector3(0, 6, 30);
        }

 public void sphere(Vector3 a, float r, Color c) {
     var s = new Sphere();
     s.At = a;
     s.Radius = r;
     s.Col = c;
     Spheres.Add(s);
 }

			internal static Scene SphereScene (int level, Vector center, double radius)
			{
				Sphere sphere = new Sphere (center, radius);
				if (level == 1) { 
					return sphere;
				} else {
					Group scene = new Group (new Sphere (center, 3.0 * radius));
					scene.Add (sphere);
					double rn = 3.0 * radius / Math.Sqrt (12.0);

					for (int dz = -1; dz <= 1; dz += 2) {
						for (int dx = -1; dx <= 1; dx += 2) {

							Vector c2 = new Vector (
								                       center.x - dx * rn
                     , center.y + rn
                     , center.z - dz * rn
							                       );

							scene.Add (SphereScene (level - 1, c2, radius / 2.0));
						}
					}
					return scene;
				}
			}

 protected CharacterCardBase(CardType printedCardType, string title, CardSet cardSet, uint cardNumber, Sphere printedSphere, byte printedWillpower, byte printedAttack, byte printedDefense, byte printedHitPoints)
     : base(printedCardType, title, cardSet, cardNumber, printedSphere)
 {
     this.PrintedWillpower = printedWillpower;
     this.PrintedAttack = printedAttack;
     this.PrintedDefense = printedDefense;
     this.PrintedHitPoints = printedHitPoints;
 }

 public MainForm()
 {
     InitializeComponent();
     p = new Perspective(this);
     testSphere = new Sphere (new Point3(100, 100, 0), 100, Color.Yellow);
     testSphere2 = new Sphere (new Point3 (250, 250, 0), 50, Color.Blue);
     testSphere3 = new Sphere (new Point3 (250, 250, 0), 10, Color.Wheat);
 }

 private void SetUp()
 {
     //Earth diameter is 0.042479 light seconds
     diameter = 1.042479f;
     //Distance from Earth to sun is 499.2 light seconds
     distanceToStar = 499.2f;
     sphere = new Sphere(diameter / 2, device, Microsoft.Xna.Framework.Color.White, 90);
 }

 void Launch()
 {
     Sphere sphere = new Sphere(Game.Camera.Position, 1, 10);
     sphere.CollisionInformation.Events.InitialCollisionDetected += eventHandler;
     sphere.LinearVelocity = Game.Camera.WorldMatrix.Forward * 30;
     Space.Add(sphere);
     Game.ModelDrawer.Add(sphere);
 }

        //public Skybox( Game game, Camera camera ) : base( game, "skybox" )
        //{
        //    this.camera = camera;
        //}
        public GameSpace(Game game, String model)
            : base(game, model)
        {
            _sphere = new Sphere(BEPUutilities.Vector3.Zero, 100f);

            //_sphere.PositionUpdateMode = PositionUpdateMode.Continuous;
            //(game.Services.GetService(typeof(Space)) as Space).Add(_sphere);
        }

 protected override void LoadContent()
 {
     Texture2D progradeTex = Content.Load<Texture2D> ("Prograde.png");
     Texture2D hor = Content.Load<Texture2D> ("Horizon.png");
     ball = new Sphere (1.0f, graphics.GraphicsDevice, hor, progradeTex,
         Content.Load<Texture2D>("Retrograde"),Content.Load<Texture2D>("Maneuver"),Content.Load<Texture2D>("Target_prograde"),
         Content.Load<Texture2D>("Target_retrograde"));
 }

 public Asteroid(string id, int health)
     : base(id, "Asteroid_model", 1, 0, 0, 0)
 {
     _box = new Sphere(new Vector3(0, 0, 0), 1.45f, Geometric.Generate_Quaternion(0, 0, 0, 0));
     _health = health;
     _damage = 0;
     _isDead = false;
 }