public override Point PointOnBearing(Point from, double distDEG, double bearingDEG, SpatialContext ctx, Point reuse)
        {
            if (distDEG == 0)
            {
                if (reuse == null)
                {
                    return(from);
                }
                reuse.Reset(from.GetX(), from.GetY());
                return(reuse);
            }
            double bearingRAD = DistanceUtils.ToRadians(bearingDEG);
            double x          = from.GetX() + Math.Sin(bearingRAD) * distDEG;
            double y          = from.GetY() + Math.Cos(bearingRAD) * distDEG;

            if (reuse == null)
            {
                return(ctx.MakePoint(x, y));
            }
            else
            {
                reuse.Reset(x, y);
                return(reuse);
            }
        }
    public void Rotate(Point origin, float angle)
    {
        Console.Write("Previous Points: ");
        for (int i = 0; i < 4; i++)
        {
            Console.Write("(" + points[i].GetX() + "," + points[i].GetY() + ")");
        }
        Console.WriteLine("\n");

        for (int i = 0; i < 4; i++)
        {
            //Convert angle to raidians
            double radian = ((2 * Math.PI) / 360) * angle;

            //get distance between origin and rectangle point, which will also serve as hypotenuse
            double distance = Math.Sqrt(((points[i].GetX() - origin.GetX()) * (points[i].GetX() - origin.GetX())) + ((points[i].GetY() - origin.GetY()) * (points[i].GetY() - origin.GetY())));

            //New angle to find right angle triangle
            double angleB   = Math.Atan((points[i].GetY() - origin.GetY()) / (points[i].GetX() - origin.GetX()));
            double newAngle = angleB + radian;

            //get new coordinates for point. new x and y coordinates are relative to the referance point so points must be added back
            float newX = origin.GetX() + (float)(distance * Math.Cos(newAngle));
            float newY = origin.GetY() + (float)(distance * Math.Sin(newAngle));

            //set Rectangle's new coords
            points[i].SetX(newX);
            points[i].SetY(newY);
        }
    }
Beispiel #3
0
        /**
         * FindTreeNode
         *
         * @param point
         * @return OctNode
         */
        public OctNode FindTreeNode(Point point)
        {
            OctNode found;

            if (point.GetX() < OctFaces [MINX].GetVert(0).GetX() || point.GetX() >= OctFaces [MAXX].GetVert(0).GetX())
            {
                return(null);
            }
            if (point.GetY() < OctFaces [MINY].GetVert(0).GetY() || point.GetY() >= OctFaces [MAXY].GetVert(0).GetY())
            {
                return(null);
            }
            if (point.GetZ() < OctFaces [MINZ].GetVert(0).GetZ() || point.GetZ() >= OctFaces [MAXZ].GetVert(0).GetZ())
            {
                return(null);
            }
            if (Child [0] != null)
            {
                for (int i = 0; i < 8; i++)
                {
                    found = Child [i].FindTreeNode(point);
                    if (found != null)
                    {
                        return(found);
                    }
                }
            }
            return(this);
        }
Beispiel #4
0
    public void PointSuivant(Point actuelle, int valeur)
    {
        float x = actuelle.GetX() * (CELL * SPAN + WALL * SPAN) + WALL * SPAN * 2.0f;
        float y = actuelle.GetY() * (CELL * SPAN + WALL * SPAN) + WALL * SPAN * 2.0f;

        if (tab[actuelle.GetX(), actuelle.GetY()] == -1 || tab[actuelle.GetX(), actuelle.GetY()] > valeur)
        {
            tab[actuelle.GetX(), actuelle.GetY()] = 1 + valeur++;
            if (actuelle.GetEst() != null)
            {
                PointSuivant(actuelle.GetEst(), valeur);
            }
            if (actuelle.GetNord() != null)
            {
                PointSuivant(actuelle.GetNord(), valeur);
            }
            if (actuelle.GetOuest() != null)
            {
                PointSuivant(actuelle.GetOuest(), valeur);
            }
            if (actuelle.GetSud() != null)
            {
                PointSuivant(actuelle.GetSud(), valeur);
            }
        }
    }
Beispiel #5
0
        private int CheckPointSide(Point filteredPoint, Point clipLineBeg, Point clipLineEnd)
        {
            double x1;
            double x2;
            double y1;
            double y2;

            x1 = filteredPoint.GetX() - clipLineBeg.GetX();
            y2 = clipLineEnd.GetY() - clipLineBeg.GetY();
            x2 = clipLineEnd.GetX() - clipLineBeg.GetX();
            y1 = filteredPoint.GetY() - clipLineBeg.GetY();
            double sgn = x1 * y2 - x2 * y1;

            if (Math.Abs(sgn) < 0.001)
            {
                return(0);
            }
            if (sgn > 0)
            {
                return(1);
            }
            if (sgn < 0)
            {
                return(-1);
            }
            return(0);
        }
    /**
     * InsidePolygon
     *
     * @param verts
     * @param num
     * @param pt
     * @param ray
     * @return boolean
     */
    private bool InsidePolygon(Point[] verts, int num, Point pt, Ray ray)
    {
        int    cross = 0;
        int    xindex, yindex, index = 0;
        double xtest, ytest, x0, y0, x1, y1;

        if (MaxComp == 0)
        {
            xindex = 1;
            yindex = 2;
            xtest  = pt.GetY();
            ytest  = pt.GetZ();
        }
        else if (MaxComp == 1)
        {
            xindex = 0;
            yindex = 2;
            xtest  = pt.GetX();
            ytest  = pt.GetZ();
        }
        else
        {
            xindex = 0;
            yindex = 1;
            xtest  = pt.GetX();
            ytest  = pt.GetY();
        }
        x0 = GetCoord(verts[num - 1], xindex) - xtest;
        y0 = GetCoord(verts[num - 1], yindex) - ytest;
        while (num-- != 0)
        {
            x1 = GetCoord(verts[index], xindex) - xtest;
            y1 = GetCoord(verts[index], yindex) - ytest;
            if (y0 > 0.0f)
            {
                if (y1 <= 0.0f)
                {
                    if (x1 * y0 > y1 * x0)
                    {
                        cross++;
                    }
                }
            }
            else
            {
                if (y1 > 0.0f)
                {
                    if (x0 * y1 > y0 * x1)
                    {
                        cross++;
                    }
                }
            }
            x0 = x1;
            y0 = y1;
            index++;
        }
        return((cross & 1) == 1);
    }
Beispiel #7
0
	/**
	 * InsidePolygon
	 *
	 * @param verts
	 * @param num
	 * @param pt
	 * @param ray
	 * @return boolean
	 */
	private bool InsidePolygon(Point[] verts, int num, Point pt, Ray ray)
	{
		int cross = 0;
		int xindex, yindex, index = 0;
		double xtest, ytest, x0, y0, x1, y1;

		if(MaxComp == 0)
		{
			xindex = 1;
			yindex = 2;
			xtest = pt.GetY();
			ytest = pt.GetZ();
		}
		else if(MaxComp == 1)
		{
			xindex = 0;
			yindex = 2;
			xtest = pt.GetX();
			ytest = pt.GetZ();
		}
		else
		{
			xindex = 0;
			yindex = 1;
			xtest = pt.GetX();
			ytest = pt.GetY();
		}
		x0 = GetCoord(verts[num - 1], xindex) - xtest;
		y0 = GetCoord(verts[num - 1], yindex) - ytest;
		while(num-- != 0)
		{
			x1 = GetCoord(verts[index], xindex) - xtest;
			y1 = GetCoord(verts[index], yindex) - ytest;
			if(y0 > 0.0f)
			{
				if(y1 <= 0.0f)
				{
					if(x1 * y0 > y1 * x0)
					{
						cross++;
					}
				}
			}
			else
			{
				if(y1 > 0.0f)
				{
					if(x0 * y1 > y0 * x1)
					{
						cross++;
					}
				}
			}
			x0 = x1;
			y0 = y1;
			index++;
		}
		return ((cross & 1) == 1);
	}
Beispiel #8
0
        private Point GetIntersectionPoint(Point lineBeg, Point lineEnd, Point clipLineBeg, Point clipLineEnd)
        {
            double A1 = lineBeg.GetY() - lineEnd.GetY();
            double A2 = clipLineBeg.GetY() - clipLineEnd.GetY();
            double B1 = lineEnd.GetX() - lineBeg.GetX();
            double B2 = clipLineEnd.GetX() - clipLineBeg.GetX();
            double C1 = lineBeg.GetX() * lineEnd.GetY() - lineBeg.GetY() * lineEnd.GetX();
            double C2 = clipLineBeg.GetX() * clipLineEnd.GetY() - clipLineBeg.GetY() * clipLineEnd.GetX();
            double M  = B1 * A2 - B2 * A1;

            return(new Point((B2 * C1 - B1 * C2) / M, (C2 * A1 - C1 * A2) / M));
        }
Beispiel #9
0
 public void MarkWall(Point Mappos)
 {
     if (wall == false && Map[Mappos.GetX()][Mappos.GetY()][Mappos.GetZ()].Passable == true)
     {
         Map[Mappos.GetX() + 1][Mappos.GetY()][Mappos.GetZ()].GetComponent <Renderer>().material = Map[Mappos.GetX() + 1][Mappos.GetY()][Mappos.GetZ()].mat_move;
         Map[Mappos.GetX() + 1][Mappos.GetY()][Mappos.GetZ()].At_Marked = true;
         Map[Mappos.GetX()][Mappos.GetY()][Mappos.GetZ() + 1].GetComponent <Renderer>().material = Map[Mappos.GetX() + 1][Mappos.GetY()][Mappos.GetZ()].mat_move;
         Map[Mappos.GetX()][Mappos.GetY()][Mappos.GetZ() + 1].At_Marked = true;
         wall    = true;
         wallpos = Mappos;
     }
 }
Beispiel #10
0
        private void checkBBox(Point ctr, double distKm)
        {
            String msg  = "ctr: " + ctr + " distKm: " + distKm;
            double dist = distKm * DistanceUtils.KM_TO_DEG;

            Rectangle r            = dc().CalcBoxByDistFromPt(ctr, dist, ctx, null);
            double    horizAxisLat = dc().CalcBoxByDistFromPt_yHorizAxisDEG(ctr, dist, ctx);

            if (!Double.IsNaN(horizAxisLat))
            {
                Assert.True(r.RelateYRange(horizAxisLat, horizAxisLat).Intersects());
            }

            //horizontal
            if (r.GetWidth() >= 180)
            {
                double deg        = dc().Distance(ctr, r.GetMinX(), r.GetMaxY() == 90 ? 90 : -90);
                double calcDistKm = deg * DistanceUtils.DEG_TO_KM;
                Assert.True(/*msg,*/ calcDistKm <= distKm + EPS);
                //horizAxisLat is meaningless in this context
            }
            else
            {
                Point  tPt        = FindClosestPointOnVertToPoint(r.GetMinX(), r.GetMinY(), r.GetMaxY(), ctr);
                double calcDistKm = dc().Distance(ctr, tPt) * DistanceUtils.DEG_TO_KM;
                CustomAssert.EqualWithDelta(/*msg,*/ distKm, calcDistKm, EPS);
                CustomAssert.EqualWithDelta(/*msg,*/ tPt.GetY(), horizAxisLat, EPS);
            }

            //vertical
            double topDistKm = dc().Distance(ctr, ctr.GetX(), r.GetMaxY()) * DistanceUtils.DEG_TO_KM;

            if (r.GetMaxY() == 90)
            {
                Assert.True(/*msg,*/ topDistKm <= distKm + EPS);
            }
            else
            {
                CustomAssert.EqualWithDelta(msg, distKm, topDistKm, EPS);
            }
            double botDistKm = dc().Distance(ctr, ctr.GetX(), r.GetMinY()) * DistanceUtils.DEG_TO_KM;

            if (r.GetMinY() == -90)
            {
                Assert.True(/*msg,*/ botDistKm <= distKm + EPS);
            }
            else
            {
                CustomAssert.EqualWithDelta(/*msg,*/ distKm, botDistKm, EPS);
            }
        }
Beispiel #11
0
    public double GetAngle(Point a, Point b, Point c)
    {
        var ax = a.GetX() - b.GetX();
        var ay = a.GetY() - b.GetY();

        var bx = c.GetX() - b.GetX();
        var by = c.GetY() - b.GetY();

        return(Math.Acos(
                   (ax * bx + ay * by) /
                   (Math.Sqrt(ax * ax + ay * ay) *
                    Math.Sqrt(bx * bx + by * by))
                   ));
    }
Beispiel #12
0
    public static void Main()
    {
        Point myPoint = new Point(10, 15);

        Console.WriteLine("myPoint.X {0}", myPoint.GetX());
        Console.WriteLine("myPoint.Y {0}", myPoint.GetY());
    }
Beispiel #13
0
        internal static void AddContour(Path path, IList <IntPoint> contour, bool close)
        {
            IList <Point> floatContour = ConvertToFloatPoints(contour);
            Point         point        = floatContour[0];

            path.MoveTo((float)point.GetX(), (float)point.GetY());
            for (int i = 1; i < floatContour.Count; i++)
            {
                point = floatContour[i];
                path.LineTo((float)point.GetX(), (float)point.GetY());
            }
            if (close)
            {
                path.CloseSubpath();
            }
        }
Beispiel #14
0
 /**
  * Combine
  *
  * @param pt
  * @param vector
  * @param ptscale
  * @param vecscale
  * @return Point
  */
 public Point Combine(Point pt, Vector vector, double ptscale, double vecscale)
 {
     x = ptscale * pt.GetX() + vecscale * vector.GetX();
     y = ptscale * pt.GetY() + vecscale * vector.GetY();
     z = ptscale * pt.GetZ() + vecscale * vector.GetZ();
     return(this);
 }
        /// <summary>Looks to see if it's possible to move backward</summary>
        /// <param name="h">The user's character</param>
        /// <param name="r">The room the user is in</param>
        /// <param name="p">The human's location</param>
        public static void CheckLegalBackwardMove(Human h, Room r, Point p)
        {
            var    x         = p.GetX();
            var    y         = p.GetY();
            var    locations = r.GetLocations();
            object location  = locations[x, y - 1];

            if (x == r.GetExit().GetX() && (y == r.GetExit().GetY() + 1))
            {
                _exiting = true;
            }
            if (y - 1 <= 0)
            {
                return;
            }
            if (location is Enemy)
            {
                Fight(x, y - 1, h, locations);
            }
            else if (location is Barrel)
            {
                Open(x, y - 1, h, locations, "barrel");
            }
            else if (location is Chest)
            {
                Open(x, y - 1, h, locations, "chest");
            }
            else if (((Point)location).IsAccessible())
            {
                p.Back();
            }
        }
 protected internal override Rectangle GetObjectBoundingBox(SvgDrawContext context)
 {
     SetPoints(GetAttribute(SvgConstants.Attributes.POINTS));
     if (points.Count > 1)
     {
         Point  firstPoint = points[0];
         double minX       = firstPoint.GetX();
         double minY       = firstPoint.GetY();
         double maxX       = minX;
         double maxY       = minY;
         for (int i = 1; i < points.Count; ++i)
         {
             Point  current  = points[i];
             double currentX = current.GetX();
             minX = Math.Min(minX, currentX);
             maxX = Math.Max(maxX, currentX);
             double currentY = current.GetY();
             minY = Math.Min(minY, currentY);
             maxY = Math.Max(maxY, currentY);
         }
         double width  = maxX - minX;
         double height = maxY - minY;
         return(new Rectangle((float)minX, (float)minY, (float)width, (float)height));
     }
     else
     {
         return(base.GetObjectBoundingBox(context));
     }
 }
        private static Point GetNextPoint(Point segStart, Point segEnd, float dist)
        {
            Point vector     = ComponentwiseDiff(segEnd, segStart);
            Point unitVector = GetUnitVector(vector);

            return(new Point(segStart.GetX() + dist * unitVector.GetX(), segStart.GetY() + dist * unitVector.GetY()));
        }
    private static double GetLengthOfSide(Point first, Point second)
    {
        double X = Math.Pow(Math.Abs(first.GetX() - second.GetX()), 2);
        double Y = Math.Pow(Math.Abs(first.GetY() - second.GetY()), 2);

        return(Math.Sqrt(X + Y));
    }
Beispiel #19
0
        static public void Test_A2(Point point)
        {
            double x = point.GetX();
            double y = point.GetY();
            double z = point.GetZ();

            Debug.Assert(Program.IsApprox(x, 636784.74, 0.01));
            Debug.Assert(Program.IsApprox(y, 849106.66, 0.01));
            Debug.Assert(Program.IsApprox(z, 426.71, 0.01));

            double time = point.GetTime();

            Debug.Assert(Program.IsApprox(time, 245382.13595, 0.00001));

            Debug.Assert(point.GetIntensity() == 118);
            Debug.Assert(point.GetReturnNumber() == 1);
            Debug.Assert(point.GetNumberOfReturns() == 1);

            Classification classif = point.GetClassification();

            Debug.Assert(classif.GetClassName() == "Unclassified");
            Debug.Assert(!classif.IsKeyPoint());
            Debug.Assert(!classif.IsSynthetic());
            Debug.Assert(!classif.IsWithheld());

            Color color = point.GetColor();

            Debug.Assert(color.GetRed() == 112);
            Debug.Assert(color.GetGreen() == 97);
            Debug.Assert(color.GetBlue() == 114);
        }
Beispiel #20
0
        protected internal override Cell GetCell(Point p, int level)
        {
            IList <Cell> cells = new List <Cell>(1);

            Build(xmid, ymid, 0, cells, new StringBuilder(), ctx.MakePoint(p.GetX(), p.GetY()), level);
            return(cells[0]);
        }
Beispiel #21
0
        public SpatialRelation Relate(Point pt)
        {
            //TODO if not jtsPoint, test against bbox to avoid JTS if disjoint
            var jtsPoint = (NtsPoint)(pt is NtsPoint ? pt : ctx.MakePoint(pt.GetX(), pt.GetY()));

            return(geom.Disjoint(jtsPoint.GetGeom()) ? SpatialRelation.DISJOINT : SpatialRelation.CONTAINS);
        }
 public virtual double GetAutoOrientAngle(MarkerSvgNodeRenderer marker, bool reverse)
 {
     if (points.Count > 1)
     {
         Vector v = new Vector(0, 0, 0);
         if (SvgConstants.Attributes.MARKER_END.Equals(marker.attributesAndStyles.Get(SvgConstants.Tags.MARKER)))
         {
             Point lastPoint         = points[points.Count - 1];
             Point secondToLastPoint = points[points.Count - 2];
             v = new Vector((float)(lastPoint.GetX() - secondToLastPoint.GetX()), (float)(lastPoint.GetY() - secondToLastPoint
                                                                                          .GetY()), 0f);
         }
         else
         {
             if (SvgConstants.Attributes.MARKER_START.Equals(marker.attributesAndStyles.Get(SvgConstants.Tags.MARKER)))
             {
                 Point firstPoint  = points[0];
                 Point secondPoint = points[1];
                 v = new Vector((float)(secondPoint.GetX() - firstPoint.GetX()), (float)(secondPoint.GetY() - firstPoint.GetY
                                                                                             ()), 0f);
             }
         }
         Vector xAxis    = new Vector(1, 0, 0);
         double rotAngle = SvgCoordinateUtils.CalculateAngleBetweenTwoVectors(xAxis, v);
         return(v.Get(1) >= 0 && !reverse ? rotAngle : rotAngle * -1f);
     }
     return(0);
 }
        protected override Node GetNode(Point p, int level)
        {
            var cells = new List <Node>(1);

            Build(xmid, ymid, 0, cells, new StringBuilder(), ctx.MakePoint(p.GetX(), p.GetY()), level);
            return(cells[0]);           //note cells could be longer if p on edge
        }
Beispiel #24
0
    /// <summary>
    /// This method translates the statistics data to ui coordinates.
    /// </summary>
    private Vector2 GetPositionFromPoint(Point point)
    {
        // get the minimum and the maximum value of the statistics
        float yMin = statistics.GetYMin();
        float yMax = statistics.GetYMax();

        // If the statistics has neither yMin nor yMax calculated, ...
        if (statistics.GetPoints().Count < 2)
        {
            // ... return this default position.
            return(new Vector2(0, 0));
        }

        // get the x object of the point
        object xObj = point.GetX();

        // the x value that is computed next
        float x = GetXValue(xObj);

        // get the y value of the point
        float y = point.GetY();

        // get the size of the panel
        RectTransform rt     = scrollView.GetComponent <RectTransform>();
        float         height = rt.sizeDelta.y;
        float         width  = rt.sizeDelta.x;

        // compute the ui coordinate and return it
        float percentageOfHeight = (y - yMin) / (yMax - yMin);

        float uiX = x * widthPerUnit - width / 2;
        float uiY = -height / 2 + percentageOfHeight * (height - yDistance);

        return(new Vector2(uiX, uiY));
    }
        /// <summary>Looks to see if it's possible to move right</summary>
        /// <param name="h">The user's character</param>
        /// <param name="r">The room the user is in</param>
        /// <param name="p">The human's location</param>
        public static void CheckLegalRightMove(Human h, Room r, Point p)
        {
            var    x         = p.GetX();
            var    y         = p.GetY();
            var    locations = r.GetLocations();
            object location  = locations[x + 1, y];

            if (x == r.GetExit().GetX() - 1 && (y == r.GetExit().GetY()))
            {
                _exiting = true;
            }
            if (x + 1 >= r.GetWidth() - 1)
            {
                return;
            }
            if (location is Enemy)
            {
                Fight(x + 1, y, h, locations);
            }
            else if (location is Barrel)
            {
                Open(x + 1, y, h, locations, "barrel");
            }
            else if (location is Chest)
            {
                Open(x + 1, y, h, locations, "chest");
            }
            else if (((Point)location).IsAccessible())
            {
                p.Right();
            }
        }
Beispiel #26
0
 public Rectangle(Point top_left, Point bottom_right)
 {
     this.top_left     = top_left;
     this.bottom_right = bottom_right;
     corners           = new Point[] { top_left, new Point(bottom_right.GetX(), top_left.GetY()),
                                       new Point(top_left.GetX(), bottom_right.GetY()), bottom_right };
     size = new double[] { corners[0].Distance(corners[1]), corners[1].Distance(corners[1]) };
 }
Beispiel #27
0
    public bool IsEqual(Point rhs)
    {
        if (rhs.GetX() == this.x && rhs.GetY() == this.y && rhs.GetRotation() == this.rotation) {
            return true;
        }

        return false;
    }
Beispiel #28
0
    public int GetDistance(Hex h1, Hex h2)
    {
        Point pos1 = h1.MapPos;
        Point pos2 = h2.MapPos;

        return((int)(Mathf.Sqrt(Mathf.Pow(pos1.GetX() - pos2.GetX(), 2) + Mathf.Pow((pos1.GetZ() - pos2.GetZ()), 2))));
        // return((pos1.GetX() - pos2.GetX())+( pos1.GetZ() - pos2.GetZ()));
    }
Beispiel #29
0
 void RepositionDesert2Checkpoint()
 {
     rb.velocity = new  Vector3(0, 0, 0);
     carInGame.transform.position = new Vector3(coordinates.GetX(), coordinates.GetY(), coordinates.GetZ());         //1537, 0, 348
     carInGame.SendMessage("updateTimeByRepositionDesert2");
     //carInGame.transform.rotation = Quaternion.Euler (0.0f, -54.658f, 0.0f);
     Debug.Log("riposizionato");
 }
        /// <summary>
        /// Assign the vertices of the entity.
        /// </summary>
        /// <param name="x">X vertice to assign.</param>
        /// <param name="y">Y vertice to assign.</param>
        /// <returns>The entity with its vertices assigned.</returns>
        public static Point AssignVertice(Point x, Point y)
        {
            int   axis     = x.GetX();
            int   yi       = y.GetY();
            Point auxiliar = new Point(axis, yi);

            return(auxiliar);
        }
Beispiel #31
0
        public double EucledianDistance(Point point1, Point point2)
        {
            double xValue = Math.Pow((point1.GetX() - point2.GetX()), 2);
            double yValue = Math.Pow((point1.GetY() - point2.GetY()), 2);
            double result = Math.Sqrt(xValue + yValue);

            return(result);
        }
        public override Rectangle CalcBoxByDistFromPt(Point from, double distDEG, SpatialContext ctx, Rectangle reuse)
        {
            double minX = from.GetX() - distDEG;
            double maxX = from.GetX() + distDEG;
            double minY = from.GetY() - distDEG;
            double maxY = from.GetY() + distDEG;

            if (reuse == null)
            {
                return(ctx.MakeRectangle(minX, maxX, minY, maxY));
            }
            else
            {
                reuse.Reset(minX, maxX, minY, maxY);
                return(reuse);
            }
        }
Beispiel #33
0
	/**
	 * SphereObj
	 *
	 * @param objmaterial
	 * @param newobjID
	 * @param neworigin
	 * @param newradius
	 * @param MaxX
	 * @param MinX
	 * @param MaxY
	 * @param MinY
	 * @param MaxZ
	 * @param MinZ
	 */
	public SphereObj(Material objmaterial, int newobjID, Point neworigin, double newradius, Point max, Point min)
		: base(objmaterial, newobjID)
	{
		Origin = neworigin;
		Radius = newradius;

		RadiusSquare = Radius * Radius;
		GetMax().SetX(Origin.GetX() + Radius);
		GetMax().SetY(Origin.GetY() + Radius);
		GetMax().SetZ(Origin.GetZ() + Radius);
		GetMin().SetX(Origin.GetX() - Radius);
		GetMin().SetY(Origin.GetY() - Radius);
		GetMin().SetZ(Origin.GetZ() - Radius);
		if(GetMax().GetX() > max.GetX())
		{
			max.SetX(GetMax().GetX());
		}
		if(GetMax().GetY() > max.GetY())
		{
			max.SetY(GetMax().GetY());
		}
		if(GetMax().GetZ() > max.GetZ())
		{
			max.SetZ(GetMax().GetZ());
		}
		if(GetMin().GetX() < min.GetX())
		{
			min.SetX(GetMin().GetX());
		}
		if(GetMin().GetY() < min.GetY())
		{
			min.SetY(GetMin().GetY());
		}
		if(GetMin().GetZ() < min.GetZ())
		{
			min.SetZ(GetMin().GetZ());
		}
	}
Beispiel #34
0
	/**
	 * Intersect
	 *
	 * @param ray
	 * @param intersect
	 * @param Threshold
	 * @return OctNode
	 */
	public OctNode Intersect(Ray ray, Point intersect, double Threshold)
	{
		Vector delta = new Vector(0.0f, 0.0f, 0.0f);
		double current = 0.0f;
		double t;
		int[] facehits = new int[3];
		facehits[0] = -1;
		facehits[1] = -1;
		facehits[2] = -1;
		OctNode adjacent = null;

		Face[] OFaces = this.OctFaces;
		Face MAXXF = OFaces[MAXX];
		Face MAXYF = OFaces[MAXY];
		Face MAXZF = OFaces[MAXZ];
		Face MINXF = OFaces[MINX];
		Face MINYF = OFaces[MINY];
		Face MINZF = OFaces[MINZ];

		if(ray.GetDirection().GetX() != 0.0)
		{
			t = -(ray.GetOrigin().GetX() - OctFaces[MAXX].GetVert(0).GetX()) / ray.GetDirection().GetX();
			if(t > Threshold && t > current)
			{
				intersect.Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, t);
				if((intersect.GetY() <= MAXYF.GetVert(0).GetY()) && (intersect.GetY() >= MINYF.GetVert(0).GetY()) &&
					(intersect.GetZ() <= MAXZF.GetVert(0).GetZ()) && (intersect.GetZ() >= MINZF.GetVert(0).GetZ()))
				{
					current = t;
					facehits[0] = MAXX;
					delta.SetX(Threshold);
				}
			}
			t = -(ray.GetOrigin().GetX() - OctFaces[MINX].GetVert(0).GetX()) / ray.GetDirection().GetX();
			if(t > Threshold && t > current)
			{
				intersect.Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, t);
				if((intersect.GetY() <= MAXYF.GetVert(0).GetY()) && (intersect.GetY() >= MINYF.GetVert(0).GetY()) &&
					(intersect.GetZ() <= MAXZF.GetVert(0).GetZ()) && (intersect.GetZ() >= MINZF.GetVert(0).GetZ()))
				{
					current = t;
					facehits[0] = MINX;
					delta.SetX(-Threshold);
				}
			}
		}
		if(ray.GetDirection().GetY() != 0.0)
		{
			t = -(ray.GetOrigin().GetY() - OctFaces[MAXY].GetVert(0).GetY()) / ray.GetDirection().GetY();
			if(t > Threshold)
			{
				if(t > current)
				{
					intersect.Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, t);
					if((intersect.GetX() <= MAXXF.GetVert(0).GetX()) && (intersect.GetX() >= MINXF.GetVert(0).GetX()) &&
						(intersect.GetZ() <= MAXZF.GetVert(0).GetZ()) && (intersect.GetZ() >= MINZF.GetVert(0).GetZ()))
					{
						current = t;
						facehits[0] = MAXY;
						delta.Set(0.0f, Threshold, 0.0f);
					}
				}
				else if(t == current)
				{
					facehits[1] = MAXY;
					delta.SetY(Threshold);
				}
			}
			t = -(ray.GetOrigin().GetY() - OctFaces[MINY].GetVert(0).GetY()) / ray.GetDirection().GetY();
			if(t > Threshold)
			{
				if(t > current)
				{
					intersect.Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, t);
					if((intersect.GetX() <= MAXXF.GetVert(0).GetX()) && (intersect.GetX() >= MINXF.GetVert(0).GetX()) &&
						(intersect.GetZ() <= MAXZF.GetVert(0).GetZ()) && (intersect.GetZ() >= MINZF.GetVert(0).GetZ()))
					{
						current = t;
						facehits[0] = MINY;
						delta.Set(0.0f, -Threshold, 0.0f);
					}
				}
				else if(t == current)
				{
					facehits[1] = MINY;
					delta.SetY(-Threshold);
				}
			}
		}
		if(ray.GetDirection().GetZ() != 0.0)
		{
			t = -(ray.GetOrigin().GetZ() - OctFaces[MAXZ].GetVert(0).GetZ()) / ray.GetDirection().GetZ();
			if(t > Threshold)
			{
				if(t > current)
				{
					intersect.Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, t);
					if((intersect.GetX() <= MAXXF.GetVert(0).GetX()) && (intersect.GetX() >= MINXF.GetVert(0).GetX()) &&
						(intersect.GetY() <= MAXYF.GetVert(0).GetY()) && (intersect.GetY() >= MINYF.GetVert(0).GetY()))
					{
						current = t;
						facehits[0] = MAXZ;
						delta.Set(0.0f, 0.0f, Threshold);
					}
				}
				else if(t == current)
				{
					if(facehits[1] < 0)
					{
						facehits[1] = MAXZ;
					}
					else
					{
						facehits[2] = MAXZ;
					}
					delta.SetZ(Threshold);
				}
			}
			t = -(ray.GetOrigin().GetZ() - OctFaces[MINZ].GetVert(0).GetZ()) / ray.GetDirection().GetZ();
			if(t > Threshold)
			{
				if(t > current)
				{
					intersect.Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, t);
					if((intersect.GetX() <= MAXXF.GetVert(0).GetX()) && (intersect.GetX() >= MINXF.GetVert(0).GetX()) &&
						(intersect.GetY() <= MAXYF.GetVert(0).GetY()) && (intersect.GetY() >= MINYF.GetVert(0).GetY()))
					{
						current = t;
						facehits[0] = MINZ;
						delta.Set(0.0f, 0.0f, -Threshold);
					}
				}
				else if(t == current)
				{
					if(facehits[1] < 0)
					{
						facehits[1] = MINZ;
					}
					else
					{
						facehits[2] = MINZ;
					}
					delta.SetZ(-Threshold);
				}
			}
		}
		if(facehits[0] >= MAXX)
		{
			intersect.Combine(ray.GetOrigin(), ray.GetDirection(), 1.0f, current);
			intersect.Add(delta);
			adjacent = Adjacent[facehits[0]];
			if(facehits[1] >= MAXX)
			{
				if(adjacent != null)
				{
					adjacent = adjacent.GetAdjacent(facehits[1]);
					if(facehits[2] >= MAXX)
					{
						if(adjacent != null)
						{
							adjacent = adjacent.GetAdjacent(facehits[2]);
						}
						else
						{
							adjacent = null;
						}
					}
				}
				else
				{
					adjacent = null;
				}
			}
		}
		return (adjacent);
	}
Beispiel #35
0
 public Node GetNode(Point c)
 {
     int TempX = (int) c.GetX();
     int TempY = (int) c.GetY();
     if(TempX >= 0 && TempX < xLength && TempY >= 0 && TempY < yLength) {
         return GridArray[TempX, TempY];
     }
     return null;
 }
Beispiel #36
0
 public SpatialRelation Relate(Point pt)
 {
     //TODO if not jtsPoint, test against bbox to avoid JTS if disjoint
     var jtsPoint = (NtsPoint)(pt is NtsPoint ? pt : ctx.MakePoint(pt.GetX(), pt.GetY()));
     return geom.Disjoint(jtsPoint.GetGeom()) ? SpatialRelation.DISJOINT : SpatialRelation.CONTAINS;
 }
Beispiel #37
0
 public double DistanceTo(Point p)
 {
     return Math.Sqrt(Math.Pow(p.GetX (), 2) + Math.Pow(p.GetY(), 2));
 }
Beispiel #38
0
	/**
	 * GetCoord
	 *
	 * @param pt
	 * @param index
	 * @return double
	 */
	private double GetCoord(Point pt, int index)
	{
		if(index == 0)
			return (pt.GetX());
		else if(index == 1)
			return (pt.GetY());
		else
			return (pt.GetZ());
	}
Beispiel #39
0
	/**
	 * ReadSphere
	 *
	 * @param infile
	 * @param ObjID
	 * @return int
	 */
	private int ReadSphere(int ObjID)
	{
		String temp;
		double[] input = new double[3];
		int i;
		double radius;
		Point max = new Point(MaxX, MaxY, MaxZ);
		Point min = new Point(MinX, MinY, MinZ);

		temp = readString();
		temp = readString();
		Material theMaterial = ReadMaterial();
		temp = readString();
		temp = temp.Substring(9);
		for(i = 0; i < 2; i++)
		{
			input[i] = (double)Double.Parse(temp.Substring(0, temp.IndexOf(' ')));
			temp = temp.Substring(temp.IndexOf(' ') + 1);
		}
		input[2] = (double)Double.Parse(temp);
		Point origin = new Point(input[0], input[1], input[2]);
		temp = readString();
		temp = temp.Substring(9);
		radius = (double)Double.Parse(temp);
		for(i = 0; i < 7; i++)
		{
			temp = readString();
		}
		SphereObj newsphere = new SphereObj(theMaterial, ++ObjID, origin, radius, max, min);
		ObjNode newnode = new ObjNode(newsphere, objects);
		objects = newnode;
		MaxX = max.GetX();
		MaxY = max.GetY();
		MaxZ = max.GetZ();
		MinX = min.GetX();
		MinY = min.GetY();
		MinZ = min.GetZ();

		return (1);
	}
Beispiel #40
0
	/**
	 * Sub
	 *
	 * @param op1
	 * @param op2
	 * @return Vector
	 */
	public Vector Sub(Point op1, Point op2)
	{
		Set(op1.GetX() - op2.GetX(), op1.GetY() - op2.GetY(), op1.GetZ() - op2.GetZ());
		return (this);
	}
Beispiel #41
0
		/**
	 * Combine
	 *
	 * @param pt
	 * @param vector
	 * @param ptscale
	 * @param vecscale
	 * @return Point
	 */
		public Point Combine (Point pt, Vector vector, double ptscale, double vecscale)
		{
			x = ptscale * pt.GetX () + vecscale * vector.GetX ();
			y = ptscale * pt.GetY () + vecscale * vector.GetY ();
			z = ptscale * pt.GetZ () + vecscale * vector.GetZ ();
			return (this);
		}
Beispiel #42
0
		/**
	 * FindCorner
	 *
	 * @param view
	 * @param up
	 * @param plane
	 * @param origin
	 */
		public void FindCorner (Vector view, Vector up, Vector plane, Point origin)
		{
			x = origin.GetX ();
			y = origin.GetY ();
			z = origin.GetZ ();
			Add (view);
			Add (up);
			Add (plane);
		}
Beispiel #43
0
    public void Link(GameObject crystal)
    {
        if (crystal != null)//水晶连线   && linkStop == false
        {
            if (!draw)//如果还没开始画线
            {
                //if (EnergyManager.Instance.accessibleEnergy > 0)
                {
                    #region
                    float x = 0, z = 0; int kx = -1, ky = -1;
                    linePoints = new Vector3[2];
                    linePoints[0] = crystal.transform.position;
                    z = EnergyManager.Instance.HeroMagicCircle.getz(linePoints[0].z);
                    if (z == EnergyManager.Instance.HeroMagicCircle.rowKey[2])
                        x = EnergyManager.Instance.HeroMagicCircle.getx1(linePoints[0].x);
                    else if (z == EnergyManager.Instance.HeroMagicCircle.rowKey[0] || z == EnergyManager.Instance.HeroMagicCircle.rowKey[4])
                        x = EnergyManager.Instance.HeroMagicCircle.getx2(linePoints[0].x);
                    else
                        x = EnergyManager.Instance.HeroMagicCircle.getx3(linePoints[0].x);
                    kx = EnergyManager.Instance.HeroMagicCircle.getKx(x);
                    ky = EnergyManager.Instance.HeroMagicCircle.getKy(z);
                    if (kx != -1)
                    {
                        l1 = new Point( kx , ky);
                        draw = true;
                        //EnergyManager.Instance.MinusEnergy(1);
                    }
                    screenSpace = Camera.main.WorldToScreenPoint(crystal.transform.position);
                    linePoints[1] = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, screenSpace.z));
                    temp1 = new VectorLine("3DLine", linePoints, Color.green, lineMaterial, 8.0f);
                    temp2 = new VectorLine("3DLine", linePoints, Color.green, lineMaterial2, 15.0f);
                    temp1.Draw3DAuto();
                    temp2.Draw3DAuto();
                    #endregion
                }
                //else
                //{
                //    //linkStop = true;
                //}
            }
            else
            {
                #region
                float x = 0, z = 0; int kx = -1, ky = -1;
                linePoints[1] = crystal.transform.position;
                z = EnergyManager.Instance.HeroMagicCircle.getz(linePoints[1].z);
                if (z == EnergyManager.Instance.HeroMagicCircle.rowKey[2])
                    x = EnergyManager.Instance.HeroMagicCircle.getx1(linePoints[1].x);
                else if (z == EnergyManager.Instance.HeroMagicCircle.rowKey[0] || z == EnergyManager.Instance.HeroMagicCircle.rowKey[4])
                    x = EnergyManager.Instance.HeroMagicCircle.getx2(linePoints[1].x);
                else
                    x = EnergyManager.Instance.HeroMagicCircle.getx3(linePoints[1].x);
                kx = EnergyManager.Instance.HeroMagicCircle.getKx(x);
                ky = EnergyManager.Instance.HeroMagicCircle.getKy(z);
                l2 = new Point(kx , ky);
                if (l2 == l1)//连自己=>取消连线
                {
                    VectorLine.Destroy(ref temp1);
                    VectorLine.Destroy(ref temp2);
                    //EnergyManager.Instance.MinusEnergy(-1);
                }
                else if (EnergyManager.Instance.HeroMagicCircle.IsOperable(new Line(l1,l2)))
                {
                    if (kx != -1 && !EnergyManager.Instance.HeroMagicCircle.GetLine(l1, l2) && EnergyManager.Instance.HeroMagicCircle.GetLineSwitch(l1.GetX(), l1.GetY(), l2.GetX(), l2.GetY()))//画线
                    {
                        //AddLine(l1, l2);
                        if (EnergyManager.Instance.accessibleEnergy>0)
                        {
                            temp1.Draw3D();
                            temp2.Draw3D();
                            line[l1.GetUni(), l2.GetUni()] = temp1; line2[l1.GetUni(), l2.GetUni()] = temp2;
                            EnergyManager.Instance.HeroMagicCircle.LineTrue(l1.GetUni(), l2.GetUni());
                            EnergyManager.Instance.MinusEnergy(1);
                        }
                        else
                        {
                            VectorLine.Destroy(ref temp1);
                            VectorLine.Destroy(ref temp2);
                            GuideText.Instance.ReturnText("LinkNeedEnergy");
                        }
                    }
                    else if (EnergyManager.Instance.HeroMagicCircle.GetLine(l1, l2))//删线
                    {

                        // Debug.Log("delete");
                        DeleteLine(l1, l2);
                        VectorLine.Destroy(ref temp1);
                        VectorLine.Destroy(ref temp2);
                        GuideText.Instance.GuideLevel(2, 33, "RedundentLink");
                        GuideText.Instance.GuideLevel(3, 33, "RedundentLink");
                        //EnergyManager.Instance.MinusEnergy(-1);
                        //linkStop = true;
                    }
                }
                else
                {
                    GuideText.Instance.ReturnText("NoJumpLink");
                    return;
                }
                draw = false;
                #endregion
            }
        }
    }
Beispiel #44
0
		/**
	 * Point
	 *
	 * @param newpoint
	 */
		public Point (Point newpoint)
		{
			Set (newpoint.GetX (), newpoint.GetY (), newpoint.GetZ ());
		}
Beispiel #45
0
	/**
	 * RenderScene
	 */
	public void RenderScene(Canvas canvas, int width, int section, int nsections)
	{
		Vector view = camera.GetViewDir();
		Vector up = camera.GetOrthoUp();
		Vector plane = new Vector();
		Vector horIncr = new Vector();
		Vector vertIncr = new Vector();
		double ylen = camera.GetFocalDist() * (double)Math.Tan(0.5f * camera.GetFOV());
		double xlen = ylen * canvas.GetWidth() / canvas.GetHeight();
		Point upleft = new Point();
		Point upright = new Point();
		Point lowleft = new Point();
		Point basepoint = new Point();
		Point current;
		Ray eyeRay = new Ray();
		int ypixel, xpixel;

		RayID = 1;
		plane.Cross(view, up);
		view.Scale(camera.GetFocalDist());
		up.Scale(ylen);
		plane.Scale(-xlen);
		upleft.FindCorner(view, up, plane, camera.GetPosition());
		plane.Negate();
		upright.FindCorner(view, up, plane, camera.GetPosition());
		up.Negate();
		plane.Negate();
		lowleft.FindCorner(view, up, plane, camera.GetPosition());
		horIncr.Sub(upright, upleft);
		horIncr.Scale(horIncr.Length() / ((double)canvas.GetWidth()));
		vertIncr.Sub(lowleft, upleft);
		vertIncr.Scale(vertIncr.Length() / ((double)canvas.GetHeight()));
		basepoint.Set(upleft.GetX() + 0.5f * (horIncr.GetX() + vertIncr.GetX()), upleft.GetY() + 0.5f * (horIncr.GetY() + vertIncr.GetY()),
			upleft.GetZ() + 0.5f * (horIncr.GetZ() + vertIncr.GetZ()));
		eyeRay.SetOrigin(camera.GetPosition());

		int xstart = section * width / nsections;
		int xend = xstart + width / nsections;

		Console.WriteLine("+" + xstart + " to " + (xend - 1) + " by " + canvas.GetHeight());

		for(ypixel = 0; ypixel < canvas.GetHeight(); ypixel++)
		{
			current = new Point(basepoint);
			for(xpixel = 0; xpixel < canvas.GetWidth(); xpixel++)
			{
				if(xpixel >= xstart && xpixel < xend)
				{
					Color color = new Color(0.0f, 0.0f, 0.0f);
					eyeRay.GetDirection().Sub(current, eyeRay.GetOrigin());
					eyeRay.GetDirection().Normalize();
					eyeRay.SetID(RayID);
					this.RayID = this.RayID + 1;
					Shade(octree, eyeRay, color, 1.0f, 0, 0);
					canvas.Write(Brightness, xpixel, ypixel, color);
				}
				current.Add(horIncr);
			}
			basepoint.Add(vertIncr);
		}
		Console.WriteLine("-" + xstart + " to " + (xend - 1) + " by " + canvas.GetHeight());
	}
 public double Distance(Point @from, Point to)
 {
     return Distance(from, to.GetX(), to.GetY());
 }
Beispiel #47
0
	/**
	 * OctNode
	 *
	 * @param max
	 * @param min
	 */
	public OctNode(Point max, Point min)
	{
		Initialize();
		CreateFaces(max.GetX(), min.GetX(), max.GetY(), min.GetY(), max.GetZ(), min.GetZ());
	}
Beispiel #48
0
	/**
	 * ReadPoly
	 *
	 * @param infile
	 * @param ObjID
	 * @return int
	 */
	private int ReadPoly(int ObjID)
	{
		String temp;
		double[] input = new double[3];
		int i, j, k;
		int numpolys = 0;
		int numverts;
		bool trimesh, vertnormal;
		Point max = new Point(MaxX, MaxY, MaxZ);
		Point min = new Point(MinX, MinY, MinZ);

		temp = readString();
		temp = readString();
		Material theMaterial = ReadMaterial();
		temp = readString();
		if(temp.Substring(7).Equals("POLYSET_TRI_MESH"))
		{
			trimesh = true;
		}
		else
		{
			trimesh = false;
		}
		temp = readString();
		if(temp.Substring(11).Equals("PER_VERTEX_NORMAL"))
		{
			vertnormal = true;
		}
		else
		{
			vertnormal = false;
		}
		for(i = 0; i < 4; i++)
		{
			temp = readString();
		}
		temp = temp.Substring(11);
		numpolys = Int32.Parse(temp);
		ObjID++;
		for(i = 0; i < numpolys; i++)
		{
			temp = readString();
			temp = readString();
			temp = temp.Substring(16);
			numverts = Int32.Parse(temp);
			Point[] vertices = new Point[numverts];
			for(j = 0; j < numverts; j++)
			{
				temp = readString();
				temp = temp.Substring(8);
				for(k = 0; k < 2; k++)
				{
					input[k] = (double)Double.Parse(temp.Substring(0, temp.IndexOf(' ')));
					temp = temp.Substring(temp.IndexOf(' ') + 1);
				}
				input[2] = (double)Double.Parse(temp);
				vertices[j] = new Point(input[0], input[1], input[2]);
				if(vertnormal)
				{
					temp = readString();
				}
			}
			temp = readString();
			TriangleObj newtriangle;
			PolygonObj newpoly;
			ObjNode newnode;
			if(trimesh)
			{
				newtriangle = new TriangleObj(theMaterial, ObjID, numverts, vertices, max, min);
				newnode = new ObjNode(newtriangle, objects);
			}
			else
			{
				newpoly = new PolygonObj(theMaterial, ObjID, numverts, vertices, max, min);
				newnode = new ObjNode(newpoly, objects);
			}
			objects = newnode;
		}
		temp = readString();
		MaxX = max.GetX();
		MaxY = max.GetY();
		MaxZ = max.GetZ();
		MinX = min.GetX();
		MinY = min.GetY();
		MinZ = min.GetZ();

		return (numpolys);
	}
Beispiel #49
0
		public float PtLineDistSq(Point pt) {
			return PtLineDistSq(GetX1(), GetY1(), GetX2(), GetY2(), pt.GetX(),
					pt.GetY());
		}
Beispiel #50
0
	/**
	 * FindTreeNode
	 *
	 * @param point
	 * @return OctNode
	 */
	public OctNode FindTreeNode(Point point)
	{
		OctNode found;

		if(point.GetX() < OctFaces[MINX].GetVert(0).GetX() || point.GetX() >= OctFaces[MAXX].GetVert(0).GetX())
		{
			return (null);
		}
		if(point.GetY() < OctFaces[MINY].GetVert(0).GetY() || point.GetY() >= OctFaces[MAXY].GetVert(0).GetY())
		{
			return (null);
		}
		if(point.GetZ() < OctFaces[MINZ].GetVert(0).GetZ() || point.GetZ() >= OctFaces[MAXZ].GetVert(0).GetZ())
		{
			return (null);
		}
		if(Child[0] != null)
		{
			for(int i = 0; i < 8; i++)
			{
				found = Child[i].FindTreeNode(point);
				if(found != null)
				{
					return (found);
				}
			}
		}
		return (this);
	}
Beispiel #51
0
 public void KengTrue(Point p)
 {
     keng[p.GetX(), p.GetY()] = true;
 }
Beispiel #52
0
	/**
	 * CreateChildren
	 *
	 * @param objects
	 * @param depth
	 */
	private void CreateChildren(ObjNode objects, int depth)
	{

		double maxX = OctFaces[MAXX].GetVert(0).GetX();
		double minX = OctFaces[MINX].GetVert(0).GetX();
		double maxY = OctFaces[MAXY].GetVert(0).GetY();
		double minY = OctFaces[MINY].GetVert(0).GetY();
		double maxZ = OctFaces[MAXZ].GetVert(0).GetZ();
		double minZ = OctFaces[MINZ].GetVert(0).GetZ();
		Point midpt = new Point((maxX + minX) / 2.0f, (maxY + minY) / 2.0f, (maxZ + minZ) / 2.0f);
		Point max = new Point();
		Point min = new Point();
		ObjNode currentnode;
		int i;

		max.Set(maxX, maxY, maxZ);
		min.Set(midpt.GetX(), midpt.GetY(), midpt.GetZ());
		Child[0] = new OctNode(max, min);
		max.Set(maxX, midpt.GetY(), maxZ);
		min.Set(midpt.GetX(), minY, midpt.GetZ());
		Child[1] = new OctNode(max, min);
		max.Set(maxX, midpt.GetY(), midpt.GetZ());
		min.Set(midpt.GetX(), minY, minZ);
		Child[2] = new OctNode(max, min);
		max.Set(maxX, maxY, midpt.GetZ());
		min.Set(midpt.GetX(), midpt.GetY(), minZ);
		Child[3] = new OctNode(max, min);
		max.Set(midpt.GetX(), maxY, maxZ);
		min.Set(minX, midpt.GetY(), midpt.GetZ());
		Child[4] = new OctNode(max, min);
		max.Set(midpt.GetX(), midpt.GetY(), maxZ);
		min.Set(minX, minY, midpt.GetZ());
		Child[5] = new OctNode(max, min);
		max.Set(midpt.GetX(), midpt.GetY(), midpt.GetZ());
		min.Set(minX, minY, minZ);
		Child[6] = new OctNode(max, min);
		max.Set(midpt.GetX(), maxY, midpt.GetZ());
		min.Set(minX, midpt.GetY(), minZ);
		Child[7] = new OctNode(max, min);

		OctNode[] adj = this.Adjacent;
		OctNode[] chld = this.Child;

		OctNode adj0 = adj[0];
		OctNode adj1 = adj[1];
		OctNode adj2 = adj[2];
		OctNode adj3 = adj[3];
		OctNode adj4 = adj[4];
		OctNode adj5 = adj[5];

		OctNode chld0 = chld[0];
		OctNode chld1 = chld[1];
		OctNode chld2 = chld[2];
		OctNode chld3 = chld[3];
		OctNode chld4 = chld[4];
		OctNode chld5 = chld[5];
		OctNode chld6 = chld[6];
		OctNode chld7 = chld[7];

		Child[0].FormAdjacent(adj0, adj1, adj2, chld4, chld1, chld3);
		Child[1].FormAdjacent(adj0, chld0, adj2, chld5, adj4, chld2);
		Child[2].FormAdjacent(adj0, chld3, chld1, chld6, adj4, adj5);
		Child[3].FormAdjacent(adj0, adj1, chld0, chld7, chld2, adj5);
		Child[4].FormAdjacent(chld0, adj1, adj2, adj3, chld5, chld7);
		Child[5].FormAdjacent(chld1, chld4, adj2, adj3, adj4, chld6);
		Child[6].FormAdjacent(chld2, chld7, chld5, adj3, adj4, adj5);
		Child[7].FormAdjacent(chld3, adj1, chld4, adj3, chld6, adj5);
		if(objects != null)
		{
			currentnode = objects;
		}
		else
		{
			currentnode = ObjList;
		}
		while(currentnode != null)
		{
			ObjectType currentobj = currentnode.GetObj();
			for(i = 0; i < 8; i++)
			{
				OctNode cc = chld[i];
				max = cc.GetFace(0).GetVert(0);
				min = cc.GetFace(5).GetVert(3);
				if(!((currentobj.GetMin().GetX() > max.GetX()) ||
					(currentobj.GetMax().GetX() < min.GetX())))
				{
					if(!((currentobj.GetMin().GetY() > max.GetY()) ||
						(currentobj.GetMax().GetY() < min.GetY())))
					{
						if(!((currentobj.GetMin().GetZ() > max.GetZ()) ||
							(currentobj.GetMax().GetZ() < min.GetZ())))
						{
							ObjNode newnode = new ObjNode(currentobj, Child[i].GetList());
							cc.SetList(newnode);
							cc.IncNumObj();
						}
					}
				}
			}
			currentnode = currentnode.Next();
		}
		if(objects == null)
		{
			NumObj = 0;
			ObjList = null;
		}
		if(depth < MaxDepth)
		{
			for(i = 0; i < 8; i++)
			{
				if(Child[i].GetNumObj() > MaxObj)
				{
					Child[i].CreateChildren(null, depth + 1);
				}
			}
		}
	}
Beispiel #53
0
	/**
	 * PolyTypeObj
	 *
	 * @param objmaterial
	 * @param newobjID
	 * @param numverts
	 * @param vertices
	 * @param MaxX
	 * @param MinX
	 * @param MaxY
	 * @param MinY
	 * @param MaxZ
	 * @param MinZ
	 */
	protected PolyTypeObj(Material objmaterial, int newobjID, int numverts, Point[] vertices,
		Point max, Point min)
		: base(objmaterial, newobjID)
	{
		numVertices = numverts;
		Vertices = vertices;

		CalculateNormal();
		Vector temp = new Vector(Vertices[0].GetX(), Vertices[0].GetY(), Vertices[0].GetZ());
		D = -Normal.Dot(temp);
		GetMax().Set(Vertices[0].GetX(), Vertices[0].GetY(), Vertices[0].GetZ());
		GetMin().Set(Vertices[0].GetX(), Vertices[0].GetY(), Vertices[0].GetZ());
		for(int i = 1; i < numVertices; i++)
		{
			if(Vertices[i].GetX() > GetMax().GetX())
			{
				GetMax().SetX(Vertices[i].GetX());
			}
			else if(Vertices[i].GetX() < GetMin().GetX())
			{
				GetMin().SetX(Vertices[i].GetX());
			}
			if(Vertices[i].GetY() > GetMax().GetY())
			{
				GetMax().SetY(Vertices[i].GetY());
			}
			else if(Vertices[i].GetY() < GetMin().GetY())
			{
				GetMin().SetY(Vertices[i].GetY());
			}
			if(Vertices[i].GetZ() > GetMax().GetZ())
			{
				GetMax().SetZ(Vertices[i].GetZ());
			}
			else if(Vertices[i].GetZ() < GetMin().GetZ())
			{
				GetMin().SetZ(Vertices[i].GetZ());
			}
		}
		if(GetMax().GetX() > max.GetX())
		{
			max.SetX(GetMax().GetX());
		}
		if(GetMax().GetY() > max.GetY())
		{
			max.SetY(GetMax().GetY());
		}
		if(GetMax().GetZ() > max.GetZ())
		{
			max.SetZ(GetMax().GetZ());
		}
		if(GetMin().GetX() < min.GetX())
		{
			min.SetX(GetMin().GetX());
		}
		if(GetMin().GetY() < min.GetY())
		{
			min.SetY(GetMin().GetY());
		}
		if(GetMin().GetZ() < min.GetZ())
		{
			min.SetZ(GetMin().GetZ());
		}
	}