public override Bitmap render(BBox bbox, int width, int height, int elevation) { Bitmap mapImg = new Bitmap(width, height); Graphics gfx = Graphics.FromImage(mapImg); gfx.Clear(Color.FromArgb(0, 0, 0, 0)); Pen pen = new Pen(Color.Red); Brush brush = Brushes.Red; // draw agent position on the map try { m_scene.ForEachScenePresence(delegate(ScenePresence agent) { if (!agent.IsChildAgent) { PointF agentPos = new PointF(agent.OffsetPosition.X, agent.OffsetPosition.Y); PointF agentImgPos = Conversion.Projection(ref agentPos, ref bbox, width, height); RectangleF rect = new RectangleF(agentImgPos.X, agentImgPos.Y, 20, 20); //point width and height hard coded as 20, should be changed gfx.FillEllipse(brush, rect); } } ); } catch (Exception) { throw new Exception("agent layer rendering failed"); } gfx.Dispose(); pen.Dispose(); return mapImg; }
/// <summary> /// Gets the axis aligned bounding box of the orientated shape. /// </summary> /// <param name="orientation">The orientation of the shape.</param> /// <param name="box">The axis aligned bounding box of the shape.</param> public override void GetBoundingBox(ref Matrix3x3 orientation, out BBox box) { Mathf.Abs(ref orientation, out Matrix3x3 abs); Vector3.Transform(ref halfSize, ref abs, out Vector3 temp); box.Max = temp; Vector3.Negate(ref temp, out box.Min); }
/// <summary>Adjust the X/Y axis of the chart to cover the given area</summary> public void PositionChart(BBox area) { // Ensure the selection area is >= 1 pixel for width/height var sz = ClientToChart(new Size(1, 1)); XAxis.Set(area.MinX, Math.Max(area.MaxX, area.MinX + sz.Width)); YAxis.Set(area.MinY, Math.Max(area.MaxY, area.MinY + sz.Height)); SetCameraFromRange(); }
public override object HitTest(PointT point, Coord radius, out PointT projected) { projected = point; if (!BBox.Inflated(radius, radius).Contains(point)) { return(null); } return(HitTestPolyline(point, radius, Points, Divisions, out projected)); }
/// <summary> /// Checks the AABB of the two rigid bodies. /// </summary> /// <param name="entity1">The first body.</param> /// <param name="entity2">The second body.</param> /// <returns>Returns true if an intersection occours.</returns> public bool CheckBoundingBoxes(IBroadphaseEntity entity1, IBroadphaseEntity entity2) { BBox box1 = entity1.BoundingBox; BBox box2 = entity2.BoundingBox; return((((box1.Max.z >= box2.Min.z) && (box1.Min.z <= box2.Max.z)) && ((box1.Max.y >= box2.Min.y) && (box1.Min.y <= box2.Max.y))) && ((box1.Max.x >= box2.Min.x) && (box1.Min.x <= box2.Max.x))); }
/// <summary> /// Calculates the bounding box of the sphere. /// </summary> /// <param name="orientation">The orientation of the shape.</param> /// <param name="box">The resulting axis aligned bounding box.</param> public override void GetBoundingBox(ref Matrix3x3 orientation, out BBox box) { box.Min.x = -radius; box.Min.y = -radius; box.Min.z = -radius; box.Max.x = radius; box.Max.y = radius; box.Max.z = radius; }
public override void UpdateBounds() { var boxSize = new Vector3(Tolerence) * (Vector3.One - Axis); var boxLength = Axis * (GizmoSize * (1f + ArrowSize)); boxSize += boxLength; BoundingBox = BBox.FromCenterSize(boxLength / 2f, boxSize); }
public void BuildBBox() { var origin = EnvCell.Position.Origin; var orientation = EnvCell.Position.Orientation; var translate = Matrix4x4.CreateTranslation(new Vector3(origin.X, origin.Y, origin.Z)); var rotate = Matrix4x4.CreateFromQuaternion(new Quaternion(orientation.X, orientation.Y, orientation.Z, orientation.W)); BBox = new BBox(Polygons, rotate * translate); }
public void assertBBox(Geofence Geofence, BBox expected, GeoCoord inside, GeoCoord outside) { BBox result = new BBox(); Polygon.bboxFromGeofence(ref Geofence, ref result); Assert.True(BBox.bboxEquals(result, expected)); Assert.True(BBox.bboxContains(result, inside)); Assert.False(BBox.bboxContains(result, outside)); }
public virtual void Update(float timestep) { active = false; foreach (MassPoint point in points) { if (point.isActive && !point.isStatic) { active = true; break; } } if (!active) { return; } box = BBox.SmallBox; volume = 0.0f; mass = 0.0f; foreach (MassPoint point in points) { mass += point.Mass; box.AddPoint(point.position); } box.Min -= new Vector3(TriangleExpansion); box.Max += new Vector3(TriangleExpansion); foreach (Triangle t in triangles) { // Update bounding box and move proxy in dynamic tree. Vector3 prevCenter = t.boundingBox.Center; t.UpdateBoundingBox(); Vector3 linVel = t.VertexBody1.linearVelocity + t.VertexBody2.linearVelocity + t.VertexBody3.linearVelocity; linVel *= 1.0f / 3.0f; dynamicTree.MoveProxy(t.dynamicTreeID, ref t.boundingBox, linVel * timestep); Vector3 v1 = points[t.indices.I0].position; Vector3 v2 = points[t.indices.I1].position; Vector3 v3 = points[t.indices.I2].position; volume -= ((v2.y - v1.y) * (v3.z - v1.z) - (v2.z - v1.z) * (v3.y - v1.y)) * (v1.x + v2.x + v3.x); } volume /= 6.0f; AddPressureForces(timestep); }
private void GetMap_Click(object sender, EventArgs e) { var selectedText = cbMapType.SelectedValue.ToString(); var selectedMap = (GeneralLayers)Enum.Parse(typeof(GeneralLayers), selectedText); var left = Parse(tbLeft.Text); var right = Parse(tbRight.Text); var top = Parse(tbTop.Text); var bottom = Parse(tbBottom.Text); ActiveBBox = new BBox(left, bottom, right, top); int imageY; if (ActiveBBox.Ratio > 1) { var d = 800 / ActiveBBox.Ratio; imageY = (int)d; } else { imageY = 800; } int imageX; if (ActiveBBox.Ratio > 1) { imageX = 800; } else { var d = 800 * ActiveBBox.Ratio; imageX = (int)d; } var tmr = new GeneralMapRequest { Layers = selectedMap, BBOX = ActiveBBox, WIDTH = imageX, HEIGHT = imageY }; try { var image = ImageLoader.GetImage(tmr, 1); pbMap.Image = image; } catch (Exception exception) { Console.WriteLine(exception); } }
public override Util.WinForms.HitTestResult HitTest(PointT pos, VectorT hitTestRadius, SelType sel) { if (!BBox.Inflated(hitTestRadius.X, hitTestRadius.Y).Contains(pos)) { return(null); } if (sel == SelType.Partial) { if (PointsAreNear(pos, Points[0], hitTestRadius)) { return(new HitTestResult(this, Cursors.SizeAll, 0)); } if (PointsAreNear(pos, Points[Points.Count - 1], hitTestRadius)) { return(new HitTestResult(this, Cursors.SizeAll, Points.Count - 1)); } } else if (sel == SelType.Yes) { for (int i = 0; i < Points.Count; i++) { if (PointsAreNear(pos, Points[i], hitTestRadius)) { return(new HitTestResult(this, Cursors.SizeAll, i)); } } } PointT projected; float?where = LLShape.HitTestPolyline(pos, hitTestRadius.X, Points, EmptyList <int> .Value, out projected); if (where != null) { if (sel == SelType.Yes) { int seg = (int)where.Value; var angle = AngleMod8(Points[seg + 1].Sub(Points[seg])); switch (angle & 3) { case 0: return(new HitTestResult(this, Cursors.SizeNS, seg)); case 1: return(new HitTestResult(this, Cursors.SizeNESW, seg)); case 2: return(new HitTestResult(this, Cursors.SizeWE, seg)); case 3: return(new HitTestResult(this, Cursors.SizeNWSE, seg)); } } else { return(new HitTestResult(this, Cursors.Arrow, -1)); } } return(null); }
public void BboxIsTransmeridian() { var bboxNormal = new BBox(1.0m, 0.8m, 1.0m, 0.8m); Assert.IsFalse(bboxNormal.IsTransmeridian); var bboxTransmeridian = new BBox(1.0m, 0.8m, -Constants.H3.M_PI + 0.3m, Constants.H3.M_PI - 0.1m); Assert.IsTrue(bboxTransmeridian.IsTransmeridian); }
/// <summary> /// Creates a new box containing the two given ones. /// </summary> /// <param name="original">First box.</param> /// <param name="additional">Second box.</param> /// <param name="result">A JBBox containing the two given boxes.</param> public static void CreateMerged(ref BBox original, ref BBox additional, out BBox result) { Vector3 vector; Vector3 vector2; Vector3.Min(ref original.Min, ref additional.Min, out vector2); Vector3.Max(ref original.Max, ref additional.Max, out vector); result.Min = vector2; result.Max = vector; }
public void BboxFromGeofenceNoVertices() { var geofence = new GeoFence(); var expected = new BBox(0.0m, 0.0m, 0.0m, 0.0m); var result = geofence.ToBBox(); Assert.AreEqual(result, expected); }
public void UpdateBoundingBox() { boundingBox = BBox.SmallBox; boundingBox.AddPoint(ref owner.points[indices.I0].position); boundingBox.AddPoint(ref owner.points[indices.I1].position); boundingBox.AddPoint(ref owner.points[indices.I2].position); boundingBox.Min -= new Vector3(owner.triangleExpansion); boundingBox.Max += new Vector3(owner.triangleExpansion); }
private string BuildOsmFileRequest(Tile tile) { BBox bBox = GeoPositioningHelper.GetBBoxFromTile(tile); return(string.Format(StringConstants.OSMTileRequestPattern, Convert.ToString(bBox.MinLongitude, CultureInfoHelper.EnUSInfo), Convert.ToString(bBox.MinLatitude, CultureInfoHelper.EnUSInfo), Convert.ToString(bBox.MaxLongitude, CultureInfoHelper.EnUSInfo), Convert.ToString(bBox.MaxLatitude, CultureInfoHelper.EnUSInfo))); }
/// <summary> /// Whether the bounding box contains a given point /// </summary> /// <param name="box">Bounding box</param> /// <param name="point">Point to test</param> /// <returns>Whether the point is contained</returns> /// <!-- /// bbox.c /// ool bboxContains /// --> public static bool Contains(this BBox box, GeoCoord point) { return(point.Latitude >= box.South && point.Latitude <= box.North && box.IsTransmeridian // transmeridian case ? point.Longitude >= box.West || point.Longitude <= box.East // standard case : point.Longitude >= box.West && point.Longitude <= box.East); }
public static LocationRect getLocationRectFromBBox(BBox bbox) { LocationRect locationRect = new LocationRect(new Location(90, -180), new Location(-90, 180)); if (bbox != null) { locationRect = new LocationRect(new Location(bbox.BBox_Upper_Lat, bbox.BBox_Lower_Lon), new Location(bbox.BBox_Lower_Lat, bbox.BBox_Upper_Lon)); } return(locationRect); }
private void UpdateBBox(ID3D11Device InDevice, ID3D11DeviceContext InDContext) { // Update vertex buffer VertexLayouts.BasicLayout.Vertex[] BBoxVertices = new VertexLayouts.BasicLayout.Vertex[Objects.Count * 8]; int CurrentBBoxIndex = 0; foreach (RenderBoundingBox BBox in Objects.Values) { VertexLayouts.BasicLayout.Vertex[] Cached = BBox.GetTransformVertices(); System.Array.Copy(Cached, 0, BBoxVertices, CurrentBBoxIndex * Cached.Length, Cached.Length); CurrentBBoxIndex++; } // Update index buffer uint[] BBoxIndices = new uint[Objects.Count * 24]; CurrentBBoxIndex = 0; foreach (RenderBoundingBox BBox in Objects.Values) { uint[] CopiedIndices = new uint[BBox.Indices.Length]; for (int i = 0; i < CopiedIndices.Length; i++) { int BBoxOffset = (CurrentBBoxIndex * 8); CopiedIndices[i] = (ushort)(BBox.Indices[i] + BBoxOffset); } System.Array.Copy(CopiedIndices, 0, BBoxIndices, CurrentBBoxIndex * BBox.Indices.Length, BBox.Indices.Length); CurrentBBoxIndex++; } SizeToRender = Objects.Count * 24; if (VertexBuffer == null && IndexBuffer == null) { VertexBuffer = InDevice.CreateBuffer(BindFlags.VertexBuffer, BBoxVertices, 0, ResourceUsage.Dynamic, CpuAccessFlags.Write); IndexBuffer = InDevice.CreateBuffer(BindFlags.IndexBuffer, BBoxIndices, 0, ResourceUsage.Dynamic, CpuAccessFlags.Write); } else { // TODO: Templatize this MappedSubresource mappedResource = InDContext.Map(VertexBuffer, MapMode.WriteDiscard, MapFlags.None); unsafe { UnsafeUtilities.Write(mappedResource.DataPointer, BBoxVertices); } InDContext.Unmap(VertexBuffer); mappedResource = InDContext.Map(IndexBuffer, MapMode.WriteDiscard, MapFlags.None); unsafe { UnsafeUtilities.Write(mappedResource.DataPointer, BBoxIndices); } InDContext.Unmap(IndexBuffer); } }
public static BBox ComputeBoundingBox(Point3D[] points) { BBox result = new BBox(); for (int i = 0; i < points.Length; i++) { result.Extend(points[i]); } return(result); }
/// <summary> /// Passes a axis aligned bounding box to the shape where collision /// could occour. /// </summary> /// <param name="box">The bounding box where collision could occur.</param> /// <returns>The upper index with which <see cref="SetCurrentShape"/> can be /// called.</returns> public override int Prepare(ref BBox box) { // simple idea: the terrain is a grid. x and z is the position in the grid. // y the height. we know compute the min and max grid-points. All quads // between these points have to be checked. // including overflow exception prevention if (box.Min.x < boundings.Min.x) { minX = 0; } else { minX = (int)Math.Floor((float)((box.Min.x - sphericalExpansion) / scaleX)); minX = Math.Max(minX, 0); } if (box.Max.x > boundings.Max.x) { maxX = heightsLength0 - 1; } else { maxX = (int)Math.Ceiling((float)((box.Max.x + sphericalExpansion) / scaleX)); maxX = Math.Min(maxX, heightsLength0 - 1); } if (box.Min.z < boundings.Min.z) { minZ = 0; } else { minZ = (int)Math.Floor((float)((box.Min.z - sphericalExpansion) / scaleZ)); minZ = Math.Max(minZ, 0); } if (box.Max.z > boundings.Max.z) { maxZ = heightsLength1 - 1; } else { maxZ = (int)Math.Ceiling((float)((box.Max.z + sphericalExpansion) / scaleZ)); maxZ = Math.Min(maxZ, heightsLength1 - 1); } numX = maxX - minX; numZ = maxZ - minZ; // since every quad contains two triangles we multiply by 2. return(numX * numZ * 2); }
/// <summary> /// Gets the center of a bounding box /// </summary> /// <param name="box">input bounding box</param> /// <returns>output center coordinate</returns> /// <!-- /// bbox.c /// void bboxCenter /// --> public static GeoCoord Center(this BBox box) { decimal latitude = (box.North + box.South) / 2.0m; // If the bbox crosses the antimeridian, shift east 360 degrees decimal east = box.IsTransmeridian ? box.East + Constants.H3.M_2PI : box.East; decimal longitude = ((east + box.West) / 2.0m).ConstrainLongitude(); return(new GeoCoord(latitude, longitude)); }
public QuadTree(QuadTree parent, BBox bbox, int level) { this.parent = parent; this.bbox = bbox; this.level = level; width = bbox.xmax - bbox.xmin; height = bbox.ymax - bbox.ymin; position = new Vector3(bbox.xmin + width * 0.5f, bbox.ymin + height * 0.5f, 0.0f); objectList = new List <PPObject>(); }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { String bboxString = ""; if (value is BBox) { BBox bbox = value as BBox; bboxString = "(" + bbox.BBox_Lower_Lon + ", " + bbox.BBox_Lower_Lat + ", " + bbox.BBox_Upper_Lon + ", " + bbox.BBox_Upper_Lat + ")"; } return(bboxString); }
public Annulus(Vector3 cen, Vector3 norm, float i, float w, string name) : base(name) { center = cen; normal = norm; inner_radius = i; wall_thickness = w; bbox = new BBox(center.X - i - w, center.X + i + w, center.Y - MathUtil.Epsilon, center.Y + MathUtil.Epsilon, center.Z - i - w, center.Z + i + w); i_squared = i * i; w_squared = (i + w) * (i + w); }
/// <summary> /// Checks whether another bounding box is inside, outside or intersecting /// this box. /// </summary> /// <param name="box">The other bounding box to check.</param> /// <returns>The ContainmentType of the box.</returns> public ContainmentType Contains(ref BBox box) { ContainmentType result = ContainmentType.Disjoint; if ((((this.Max.x >= box.Min.x) && (this.Min.x <= box.Max.x)) && ((this.Max.y >= box.Min.y) && (this.Min.y <= box.Max.y))) && ((this.Max.z >= box.Min.z) && (this.Min.z <= box.Max.z))) { result = ((((this.Min.x <= box.Min.x) && (box.Max.x <= this.Max.x)) && ((this.Min.y <= box.Min.y) && (box.Max.y <= this.Max.y))) && ((this.Min.z <= box.Min.z) && (box.Max.z <= this.Max.z))) ? ContainmentType.Contains : ContainmentType.Intersects; } return(result); }
public void BboxFromLinkedGeoLoopNoVertices() { var loop = new LinkedGeoLoop(); var expected = new BBox(0.0m, 0.0m, 0.0m, 0.0m); var result = loop.ToBBox(); Assert.AreEqual(result, expected); loop.Clear(); }
// Constructor public BoardController(int size) { mOpenExitStack = new OpenExitStack(size); mSize = size; // setup bounds mBBox = new BBox(mSize); // for tracking occupied spaces InitializeGameGrid(); }
/* * def getMap (self, param): * bbox = map(float, param["bbox"].split(",")) * layer = self.getLayer(param["layers"]) * tile = layer.getTile(bbox) * if not tile: * raise Exception( * "couldn't calculate tile index for layer %s from (%s)" * % (layer.name, bbox)) * return tile */ #endregion ITile GetMap(NameValueCollection param) { var bbox = new BBox(param["bbox"]); var layer = GetLayer(param["layers"]); var tile = layer.GetTile(bbox); if (tile == null) { throw new Exception(string.Format("couldn't calculate tile index for layer {0} from ({1})", layer.Name, bbox)); } return(tile); }
protected void UpdateInternalBoundingBox() { mInternalBBox.Min = new Vector3(float.MaxValue); mInternalBBox.Max = new Vector3(float.MinValue); for (int i = 0; i < shapes.Length; i++) { shapes[i].UpdateBoundingBox(); BBox.CreateMerged(ref mInternalBBox, ref shapes[i].boundingBox, out mInternalBBox); } }
public override Bitmap render(BBox bbox, int width, int height, int elevation) { Bitmap gradientmapLd = new Bitmap("defaultstripe.png"); int pallete = gradientmapLd.Height; ITerrainChannel heightMap = m_scene.Heightmap; Bitmap WholeRegionbmp = new Bitmap((int)bbox.Width, (int)bbox.Height); Color[] colours = new Color[pallete]; for (int i = 0; i < pallete; i++) { colours[i] = gradientmapLd.GetPixel(0, i); } for (int y = 0; y < (int)bbox.Height; y++) { for (int x = 0; x < (int)bbox.Width; x++) { // 512 is the largest possible height before colours clamp int colorindex; if (elevation >= heightMap[x, y]) { colorindex = (int)(Math.Max(Math.Min(1.0, heightMap[x, y] / 512.0), 0.0) * (pallete - 1)); } else colorindex = (int)(Math.Max(Math.Min(1.0, elevation / 512.0), 0.0) * (pallete - 1)); // Handle error conditions if (colorindex > pallete - 1 || colorindex < 0) WholeRegionbmp.SetPixel(x, (int)bbox.Height - y - 1, Color.Red); else WholeRegionbmp.SetPixel(x, (int)bbox.Height - y - 1, colours[colorindex]); } } Bitmap RegionBBoxBmp = null; try { RegionBBoxBmp = new Bitmap(width, height); using (Graphics g = Graphics.FromImage(RegionBBoxBmp)) { g.SmoothingMode = SmoothingMode.HighQuality; g.PixelOffsetMode = PixelOffsetMode.HighQuality; g.CompositingQuality = CompositingQuality.HighQuality; g.InterpolationMode = InterpolationMode.HighQualityBicubic; g.DrawImage(WholeRegionbmp, new Rectangle(0, 0, width, height)); } } catch { if (RegionBBoxBmp != null) RegionBBoxBmp.Dispose(); throw; } return RegionBBoxBmp; }
public KDTree(List<Sphere> spheres, int maxPrimsPerNode) { // Store reference _primitives = spheres; _nodes = new KdTreeNode[0]; _maxPrims = maxPrimsPerNode; // Guess a usefull bound on the maximum tree depth _maxDepth = 8 + (int)(1.3*Math.Log(spheres.Count, 2)); // calculate primitive bounds, plus overall scene bounds BBox[] allPrimBounds = new BBox[_primitives.Count]; for (int i=0; i<_primitives.Count; i++) { allPrimBounds[i] = _primitives[i].getBounds(); _bounds.union( allPrimBounds[i] ); } // Allocate temporary working space BoundEdge[][] edges = new BoundEdge[3][]; for (int i = 0; i < 3; i++) { edges[i] = new BoundEdge[2 * _primitives.Count]; } // Allocate array to store overlaping primitive indices int[] primNums = new int[_primitives.Count]; int primNumsBase = 0; for(int i=0; i<_primitives.Count; i++) { primNums[i]=i; } // Arries to hold subarries of primitive indices int[] prims0 = new int[_primitives.Count]; int prims1Base = 0; int[] prims1 = new int[ (_maxDepth+1) * _primitives.Count]; Console.WriteLine("Building Tree with " + _primitives.Count + " primitives...\n"); // Start recursive construction tree buildTree(0, _bounds, allPrimBounds, primNums, primNumsBase, _primitives.Count, _maxDepth, edges, prims0, prims1, prims1Base, 0); Console.WriteLine("Finished building tree with " + nextFreeNode + " nodes"); }
public static bool IntersectBox(BBox box, RayInfo ray) { float t0 = ray.Min; float t1 = ray.Max; var rayInvDir = 1f / ray.Dir; //1f /ray.Dir; float invDirX = rayInvDir.x; if (!process_box_coord(ref t0, ref t1, box.Min.x - ray.Org.x, box.Max.x - ray.Org.x, invDirX)) return false; float invDirY = rayInvDir.y; if (!process_box_coord(ref t0, ref t1, box.Min.y - ray.Org.y, box.Max.y - ray.Org.y, invDirY)) return false; float invDirZ = rayInvDir.z; if (!process_box_coord(ref t0, ref t1, box.Min.z - ray.Org.z, box.Max.z - ray.Org.z, invDirZ)) return false; return true; }
private void buildTree( int nodeNum, BBox nodeBounds, BBox[] allPrimBounds, int[] primNums, int primNumsBase, int nPrimitives, int depth, BoundEdge[][] edges, int[] prims0, int[] prims1, int prims1base, int badRefines) { string indent = "".PadLeft(_maxDepth - depth); if (nextFreeNode == nAllocedNodes) { int nAlloc = Math.Max(2*nAllocedNodes, 512); KdTreeNode[] n = new KdTreeNode[nAlloc]; if (nAllocedNodes > 0) Array.Copy(_nodes, n, nAllocedNodes); _nodes = n; nAllocedNodes = nAlloc; } ++nextFreeNode; // *** Termination: Stop recursion if we have few enough nodes or the max depth has been reached *** if (nPrimitives <= _maxPrims || depth == 0) { _nodes[nodeNum] = KdTreeNode.makeLeaf(primNums, primNumsBase, nPrimitives); #if DEBUG Console.WriteLine(indent + _nodes[nodeNum]); #endif return; } // *** Not reached termination, so pick split plane and continue recursion *** Axis bestAxis = Axis.none; int bestOffset = -1; float bestCost = float.PositiveInfinity; float oldCost = iCost * (float)nPrimitives; float totalSA = nodeBounds.surfaceArea(); float invTotalSA = 1.0f/totalSA; Vector3 d = nodeBounds.pMax - nodeBounds.pMin; Axis axis = nodeBounds.longestAxis(); // Start by checking the longest axis int retries = 0; retrySplit: // Fill edge lists for (int i=0; i<nPrimitives; i++) { int primIndex = primNums[primNumsBase + i]; BBox bbox = allPrimBounds[primIndex]; edges[(int)axis][2*i] = new BoundEdge( getAxisVal(bbox.pMin, axis), primIndex, true); edges[(int)axis][2*i+1] = new BoundEdge(getAxisVal(bbox.pMax, axis), primIndex, false); } Array.Sort(edges[(int)axis], 0, 2*nPrimitives); // sort the edges of the first n primitives (2*n edges) // Find the best split by checking cost of every possible split plane int nBelow = 0, nAbove = nPrimitives; for (int i=0; i<2*nPrimitives; i++) { if( edges[(int)axis][i].type == BoundType.End) --nAbove; float edgeT = edges[(int)axis][i].t; if (edgeT > getAxisVal(nodeBounds.pMin, axis) && edgeT < getAxisVal(nodeBounds.pMax, axis) ) { // Compute split cost for the ith edge Axis otherAxis0 = (Axis) ( ((int)axis+1) % 3); Axis otherAxis1 = (Axis) ( ((int)axis+2) % 3); float belowSA = 2* (getAxisVal(d, otherAxis0) * getAxisVal(d, otherAxis1) + (edgeT - getAxisVal(nodeBounds.pMin, axis)) * (getAxisVal(d, otherAxis0) + getAxisVal(d, otherAxis1))); float aboveSA = 2*(getAxisVal(d, otherAxis0) * getAxisVal(d, otherAxis1) + (getAxisVal(nodeBounds.pMax, axis) - edgeT) * (getAxisVal(d, otherAxis0) + getAxisVal(d, otherAxis1))); float pBelow = belowSA * invTotalSA; float pAbove = aboveSA * invTotalSA; float eb = (nAbove == 0 || nBelow == 0) ? emptyBonus : 0; float cost = tCost + iCost * (1-eb) * (pBelow * nBelow + pAbove * nAbove); // Save this split if it is better the previous split position if(cost < bestCost) { bestCost = cost; bestAxis = axis; bestOffset = i; } } if (edges[(int)axis][i].type == BoundType.Start) ++nBelow; } // Create a leaf node if no good split was found if(bestAxis == Axis.none && retries < 2) { ++retries; axis = (Axis) ( ((int)axis+1) % 3); goto retrySplit; } if (bestCost > oldCost) ++badRefines; if (( bestCost > 4.0f * oldCost && nPrimitives < 16) || bestAxis == Axis.none || badRefines == 3) { _nodes[nodeNum] = KdTreeNode.makeLeaf(primNums, primNumsBase, nPrimitives); #if DEBUG Console.WriteLine(indent + _nodes[nodeNum] + " (split failure)"); #endif return; } // Classifiy primitives with respect to split int n0=0, n1=0; for (int i=0; i<bestOffset; i++) { if(edges[(int)bestAxis][i].type == BoundType.Start) prims0[n0++] = edges[(int)bestAxis][i].primNum; } for (int i=bestOffset+1; i<2*nPrimitives; i++) { if(edges[(int)bestAxis][i].type == BoundType.End) prims1[prims1base + n1++] = edges[(int)bestAxis][i].primNum; } // Ititalize child nodes float tsplit = edges[(int)bestAxis][bestOffset].t; BBox bounds0 = nodeBounds, bounds1 = nodeBounds; setAxisVal(ref bounds0.pMax, bestAxis, tsplit); setAxisVal(ref bounds1.pMin, bestAxis, tsplit); #if DEBUG KdTreeNode testNode = KdTreeNode.makeInternal(bestAxis, nextFreeNode, tsplit); int[] aboveIndices = new int[n1]; int[] belowIndices = new int[n0]; Array.Copy(prims0, belowIndices, n0); Array.Copy(prims1, prims1base, aboveIndices, 0, n1); Console.WriteLine(indent + testNode); Console.WriteLine(indent + " Above: { " + String.Join(",", aboveIndices) + " }"); Console.WriteLine(indent + " Below: { " + String.Join(",", belowIndices) + " }"); #endif buildTree(nodeNum+1, bounds0, allPrimBounds, prims0, 0, n0, depth-1, edges, prims0, prims1, prims1base+nPrimitives-1, badRefines); int aboveChild = nextFreeNode; _nodes[nodeNum] = KdTreeNode.makeInternal(bestAxis, aboveChild, tsplit); buildTree(aboveChild, bounds1, allPrimBounds, prims1, prims1base, n1, depth-1, edges, prims0, prims1, prims1base+nPrimitives-1, badRefines); }
public void AddBox(int x, int y, int width, int height, BBox type) { switch (type) { case BBox.Paragraph: _paragraphs.Add(FixRect(x, y, width, height)); break; case BBox.Column: _columns.Add(FixRect(x, y, width, height)); break; case BBox.Line: _lines.Add(FixRect(x, y, width, height)); break; case BBox.Character: _characters.Add(FixRect(x, y, width, height)); break; } }
public override Bitmap render(BBox bbox, int width, int height, int elevation) { LLVector3CL[] pos = new LLVector3CL[m_volumeCount]; LLVector3CL[] sca = new LLVector3CL[m_volumeCount]; LLQuaternionCL[] rot = new LLQuaternionCL[m_volumeCount]; LLVolumeParamsCL[] vop = new LLVolumeParamsCL[m_volumeCount]; TextureEntryListCL[] tel = new TextureEntryListCL[m_volumeCount]; for (int i = 0; i < m_volumeCount; i++) { pos[i] = m_positions[i]; sca[i] = m_scales[i]; rot[i] = m_rotations[i]; vop[i] = m_volumeParams[i]; tel[i] = m_textureEntryLists[i]; } MapRenderCL mr = new MapRenderCL(); string regionID = m_scene.RegionInfo.RegionID.ToString(); mr.mapRender( regionID, bbox.MinX, bbox.MinY, 0, bbox.MaxX, bbox.MaxY, (float)elevation, vop, m_volumeCount, pos, rot, sca, tel, width, height, "e:\\\\MonoImage\\\\", "e:\\\\regionMap\\\\"); Bitmap bmp = new Bitmap("e:\\\\regionMap\\\\" + regionID + ".bmp"); bmp.MakeTransparent(Color.FromArgb(0, 0, 0, 0)); return bmp; }
/// <summary> /// generate the projection Bitmap of a layer /// </summary> /// <param name="bbox">the boundary of the layer to be drawn</param> /// <param name="height">height of the output bitmap</param> /// <param name="weight">weight of the output bitmap</param> public abstract Bitmap render(BBox bbox, int height, int weight, int elevation);
public BBox(BBox b) { this.Max = b.Max; this.Min = b.Min; }
public override Bitmap render(BBox bbox, int width, int height, int elevation) { MapRenderCL mr = new MapRenderCL(); string regionID = m_scene.RegionInfo.RegionID.ToString(); try { bool result = mr.mapRender(regionID, bbox.MinX, bbox.MinY, 0, bbox.MaxX, bbox.MaxY, (float)elevation, m_primitiveList.ToArray(), m_primitiveList.Count, width, height, MapPath); if (result) { Bitmap bmp = new Bitmap(MapPath + regionID + ".bmp"); bmp.MakeTransparent(Color.FromArgb(0, 0, 0, 0)); return bmp; } else { Bitmap bmp = new Bitmap(width, height); return bmp; } } catch (Exception e) { m_log.Error(e.Message + e.StackTrace); Bitmap bmp = new Bitmap(width, height); return bmp; } }