protected override void OnMouseMove(object sender, MouseEventArgs e) { base.OnMouseMove(sender, e); GridVector2 WorldPosition = Parent.ScreenToWorld(e.X, e.Y); //Check if we should start a rectangle if (e.Button == MouseButtons.Left && oldMouse.Button != MouseButtons.Left) { this.rectangle = new GridRectangle(WorldPosition, 0, 0); } else if (e.Button == MouseButtons.Left) { if (WorldPosition.Y < this.rectangle.Bottom) this.rectangle.Bottom = WorldPosition.Y; else this.rectangle.Top = WorldPosition.Y; if (WorldPosition.X < this.rectangle.Left) this.rectangle.Left = WorldPosition.X; else this.rectangle.Right = WorldPosition.X; } //If the mouse was released we stop drawing rectangle else if (e.Button != MouseButtons.Left && oldMouse.Button == MouseButtons.Left) { this.CommandActive = false; } }
public GridTransform(SerializationInfo info, StreamingContext context) { _mapPoints = info.GetValue("_mapPoints", typeof(MappingGridVector2[])) as MappingGridVector2[]; _TriangleIndiciesCache = info.GetValue("_TriangleIndiciesCache", typeof(int[])) as int[]; _CachedMappedBounds = (GridRectangle)info.GetValue("_CachedMappedBounds", typeof(GridRectangle)); _CachedControlBounds = (GridRectangle)info.GetValue("_CachedControlBounds", typeof(GridRectangle)); LastModified = info.GetDateTime("LastModified"); }
public override TilePyramid VisibleTiles(GridRectangle VisibleBounds, double DownSample) { int roundedDownsample = NearestAvailableLevel(DownSample); GridQuad VisibleQuad = null; //Add any corners of the VisibleBounds that we can transform to the list of points List<MappingGridVector2> VisiblePoints = VisibleBoundsCorners(VolumeTransform, VisibleBounds); if (VisiblePoints.Count != 4) { //If we can't map all four corners then add all the points from the transform falling inside the visible rectangle or //connected to those points by an edge List<MappingGridVector2> listTransformPoints = this.VolumeTransform.IntersectingControlRectangle(VisibleBounds, true); VisiblePoints.AddRange(listTransformPoints); } else { VisiblePoints.Sort(new MappingGridVector2SortByMapPoints()); VisibleQuad = new GridQuad(VisiblePoints[0].MappedPoint, VisiblePoints[1].MappedPoint, VisiblePoints[2].MappedPoint, VisiblePoints[3].MappedPoint); } //OK, transform all points falling inside the section border //Starting with low-res tiles, add tiles to the list until we reach desired resolution //List<Tile> TilesToDraw = new List<Tile>(); TilePyramid TilesToDraw = new TilePyramid(VisibleBounds); if (VisiblePoints.Count < 3) return TilesToDraw; GridRectangle SectionBorder = MappingGridVector2.CalculateMappedBounds(VisiblePoints.ToArray()); int iLevel = AvailableLevels.Length - 1; int level = AvailableLevels[iLevel]; do { List<Tile> newTiles = RecursiveVisibleTiles(VisibleBounds, SectionBorder, VisibleQuad, level //PORT: AsynchTextureLoad ); //Insert at the beginning so we overwrite earlier tiles with poorer resolution TilesToDraw.AddTiles(level, newTiles.ToArray()); iLevel--; if (iLevel >= 0) level = AvailableLevels[iLevel]; } while (level >= roundedDownsample && iLevel >= 0); // Trace.WriteLine("Drawing " + TilesToDraw.Count.ToString() + " Tiles", "VolumeModel"); return TilesToDraw; }
public static int[] Triangulate(GridVector2[] points, GridRectangle bounds) { double WidthMargin = bounds.Width; double HeightMargin = bounds.Height; GridVector2[] BoundingPoints = new GridVector2[] { new GridVector2(bounds.Left - WidthMargin, bounds.Bottom - HeightMargin), new GridVector2(bounds.Right + WidthMargin, bounds.Bottom - HeightMargin), new GridVector2(bounds.Left - WidthMargin, bounds.Top + HeightMargin), new GridVector2(bounds.Right + WidthMargin, bounds.Top + HeightMargin)}; return Delaunay.Triangulate(points, BoundingPoints); }
public ScreenshotForm(GridRectangle myRect, double Downsample, int Z) { this._Z = Z; this.Rect = myRect; ViewerDownsample = Downsample; if (ScreenshotForm.UseViewerDownsampleChecked) this.Downsample = Downsample; else this.Downsample = ScreenshotForm.LastDownsampleValue; InitializeComponent(); }
public void TestGridRectangle() { GridRectangle rectA = new GridRectangle(10, 50, 20, 40); bool success = rectA.Contains(new GridVector2(10, 20)); Debug.Assert(success); success = rectA.Contains(new GridVector2(50, 40)); Debug.Assert(success); success = rectA.Contains(rectA.Center); Debug.Assert(success); GridRectangle rectBOverlaps = new GridRectangle(5, 15, 10, 21); success = rectA.Intersects(rectBOverlaps); Debug.Assert(success); success = rectA.Contains(rectBOverlaps); Debug.Assert(false == success); GridRectangle rectCNoOverlap = new GridRectangle(5, 15, 10, 19); success = rectA.Intersects(rectCNoOverlap); Debug.Assert(false == success); success = rectA.Contains(rectBOverlaps); Debug.Assert(false == success); GridRectangle rectDContained = new GridRectangle(15, 45, 25, 35); success = rectA.Intersects(rectDContained); Debug.Assert(success); success = rectA.Contains(rectDContained); Debug.Assert(success); /*Scale the rectangle and test again*/ rectA.Scale(2); Debug.Assert(-10.0 == rectA.Left && 70 == rectA.Right && 10 == rectA.Bottom && 50 == rectA.Top); /*Scale the rectangle and test again*/ rectA.Scale(0.5); Debug.Assert(10.0 == rectA.Left && 50 == rectA.Right && 20 == rectA.Bottom && 40 == rectA.Top); }
public ICollection<Location_CanvasViewModel> GetLocations(GridRectangle bounds) { List<GridVector2> foundPoints; List<Location_CanvasViewModel> foundLocations; Locations.Intersect(bounds, out foundPoints, out foundLocations); return foundLocations; }
public bool Union(GridRectangle rect) { return this.Union(rect.LowerLeft) || this.Union(rect.UpperRight); }
public static List<MappingGridVector2> ParseRotateTranslateAffineTransform(string[] parts, float pixelSpacing, int iFixedParameters, int iVariableParameters, GridRectangle MappedBounds, GridRectangle ControlBounds) { //Find the dimensions of the grid List<MappingGridVector2> mappings = new List<MappingGridVector2>(); /* GridVector2[] Points = new GridVector2[4]; GridVector2[] mappedPoints = new GridVector2[4]; GridVector2[] ctrlPoints = new GridVector2[4]; Points[0] = new GridVector2(0, 0); Points[1] = new GridVector2(MappedBounds.Width, 0); Points[2] = new GridVector2(0, MappedBounds.Height); Points[3] = new GridVector2(MappedBounds.Width, MappedBounds.Height); ctrlPoints[0] = new GridVector2(0, 0); ctrlPoints[1] = new GridVector2(ControlBounds.Width, 0); ctrlPoints[2] = new GridVector2(0, ControlBounds.Height); ctrlPoints[3] = new GridVector2(ControlBounds.Width, ControlBounds.Height); Matrix mat = Matrix.Identity; mat.M11 = System.Convert.ToSingle(parts[iVariableParameters + 2]); mat.M12 = System.Convert.ToSingle(parts[iVariableParameters + 3]); mat.M21 = System.Convert.ToSingle(parts[iVariableParameters + 4]); mat.M22 = System.Convert.ToSingle(parts[iVariableParameters + 5]); //Cheating: since the rotation matrix is //[cos(t) -sin(t)] //[sin(t) cos(t)] //we just take the asin of the parameter to find the rotation value // double theta = Math.Acos(System.Convert.ToSingle(parts[iVariableParameters + 2])); //Matrix mat = Matrix.CreateRotationZ((float)theta); mappedPoints[0] = Vector2.Transform(Points[0], mat); mappedPoints[1] = Vector2.Transform(Points[1], mat); mappedPoints[2] = Vector2.Transform(Points[2], mat); mappedPoints[3] = Vector2.Transform(Points[3], mat); Triangle controlOne = new Triangle(ctrlPoints[0], ctrlPoints[1], ctrlPoints[2]); Triangle controlTwo = new Triangle(ctrlPoints[2], ctrlPoints[1], ctrlPoints[3]); Triangle mappedOne = new Triangle(mappedPoints[0], mappedPoints[1], mappedPoints[2]); Triangle mappedTwo = new Triangle(mappedPoints[2], mappedPoints[1], mappedPoints[3]); mappings.Add(new MappingTriangle(controlOne, mappedOne)); mappings.Add(new MappingTriangle(controlTwo, mappedTwo)); */ return mappings; }
/// <summary> /// Returns true if the passed rectangle is entirely inside this rectangle /// </summary> /// <param name="rect"></param> /// <returns></returns> public bool Contains(GridRectangle rect) { //Find out if rect is inside this rectangle if (rect.Right <= this.Right && rect.Top <= this.Top && rect.Left >= this.Left && rect.Bottom >= this.Bottom) return true; return false; }
/// <summary> /// Returns true if the passed rectangle in inside or overlaps this rectangle /// </summary> /// <param name="rect"></param> /// <returns></returns> public bool Intersects(GridRectangle rect) { //Find out if the rectangles can't possibly intersect if(rect.Right < this.Left || rect.Top < this.Bottom || rect.Left > this.Right || rect.Bottom > this.Top) return false; return true; }
/// <summary> /// Takes a capture and sends it to the clipboard /// </summary> protected Microsoft.Xna.Framework.Graphics.PackedVector.Byte4[] CaptureArea(GridRectangle Rect, float Downsample) { Debug.Assert((Rect.Width / Downsample) < 4096 && (Rect.Height / Downsample) < 4096); Debug.Assert(this.PaintCallRefCount == 0); // Vector3 OriginalCameraLookAt = this.Camera.LookAt; //float OriginalCameraDistance = this.CameraDistance; // Rectangle OriginalVisibleRect = this.VisibleScreenRect; int Width = (int)Math.Round(Rect.Width / Downsample); int Height = (int)Math.Round(Rect.Height / Downsample); Microsoft.Xna.Framework.Graphics.PackedVector.Byte4[] data = new Microsoft.Xna.Framework.Graphics.PackedVector.Byte4[Width * Height]; try { // Initialize our RenderTarget ScreenshotRenderTarget = new RenderTarget2D(Device, Width, Height, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8); Device.SetRenderTarget(ScreenshotRenderTarget); bool OldAsynchTextureLoad = AsynchTextureLoad; AsynchTextureLoad = false; // Draw(Downsample); AsynchTextureLoad = OldAsynchTextureLoad; Device.SetRenderTarget(null); data = new Microsoft.Xna.Framework.Graphics.PackedVector.Byte4[ScreenshotRenderTarget.Width * ScreenshotRenderTarget.Height]; ScreenshotRenderTarget.GetData<Microsoft.Xna.Framework.Graphics.PackedVector.Byte4>(data); // Draw(); } finally { Device.SetRenderTarget(null); if (ScreenshotRenderTarget != null) { ScreenshotRenderTarget.Dispose(); ScreenshotRenderTarget = null; } // this.CameraLookAt = OriginalCameraLookAt; // this.CameraDistance = OriginalCameraDistance; } return data; }
protected override void OnMouseMove(object sender, MouseEventArgs e) { //Figure out if we are starting a rectangle if (e.Button == MouseButtons.Left && this.CommandActive) { GridVector2 NewPosition = Parent.ScreenToWorld(e.X, e.Y); double Width = NewPosition.X - Origin.X; double Height = NewPosition.Y - Origin.Y; if (Width != 0 && Height != 0) { MyRect = new GridRectangle(Origin, Width, Height); this.Color = Color.Red; this.Parent.Refresh(); } } base.OnMouseMove(sender, e); }
/// <summary> /// Allocates a new quad tree based on the current section parameters /// </summary> public static GridRectangle SectionBounds(Viking.UI.Controls.SectionViewerControl Parent, int SectionNumber) { GridRectangle bounds = new GridRectangle(); //Figure out the new boundaries for our quad-tree if(!Parent.Section.VolumeViewModel.SectionViewModels.ContainsKey(SectionNumber)) return new GridRectangle(); SectionViewModel SectionView = Parent.Section.VolumeViewModel.SectionViewModels[SectionNumber]; bounds = Parent.SectionBounds(SectionView.section); if (SectionView.ReferenceSectionAbove != null) { bounds = GridRectangle.Union(bounds, Parent.SectionBounds(SectionView.ReferenceSectionAbove)); } if (SectionView.ReferenceSectionBelow != null) { bounds = GridRectangle.Union(bounds, Parent.SectionBounds(SectionView.ReferenceSectionBelow)); } return bounds; }
/// <summary> /// Maps the provided visible bounds in volume space back to section space with the provided transform. /// </summary> /// <param name="transform"></param> /// <param name="VisibleBounds"></param> /// <returns></returns> protected List<MappingGridVector2> VisibleBoundsCorners(Geometry.Transforms.TransformBase transform, GridRectangle VisibleBounds) { List<MappingGridVector2> listBoundCorners = new List<MappingGridVector2>(4); //Add any corners of the VisibleBounds that we can transform to the list of points bool transformSuccess = false; GridVector2 TLowerLeft; GridVector2 TLowerRight; GridVector2 TUpperLeft; GridVector2 TUpperRight; transformSuccess = transform.TryInverseTransform(VisibleBounds.LowerLeft, out TLowerLeft); if(transformSuccess) listBoundCorners.Add(new MappingGridVector2(VisibleBounds.LowerLeft, TLowerLeft)); //Add any corners of the VisibleBounds that we can transform to the list of points transformSuccess = transform.TryInverseTransform(VisibleBounds.LowerRight, out TLowerRight); if(transformSuccess) listBoundCorners.Add(new MappingGridVector2(VisibleBounds.LowerRight, TLowerRight)); transformSuccess = transform.TryInverseTransform(VisibleBounds.UpperLeft, out TUpperLeft); if(transformSuccess) listBoundCorners.Add(new MappingGridVector2(VisibleBounds.UpperLeft, TUpperLeft)); transformSuccess = transform.TryInverseTransform(VisibleBounds.UpperRight, out TUpperRight); if(transformSuccess) listBoundCorners.Add(new MappingGridVector2(VisibleBounds.UpperRight, TUpperRight)); return listBoundCorners; }
/// <summary> /// Returns all points inside the requested region. /// If include adjacent is set to true we include points with an edge that crosses the border of the requested rectangle /// </summary> /// <param name="gridRect"></param> /// <returns></returns> private List<MappingGridVector2> IntersectingRectangle(GridRectangle gridRect, QuadTree<List<MappingGridTriangle>> PointTree) { List<GridVector2> Points; List<List<MappingGridTriangle>> ListofListTriangles; List<MappingGridVector2> MappingPointList= null; if (gridRect.Contains(PointTree.Border)) { MappingPointList = new List<MappingGridVector2>(_mapPoints); return MappingPointList; } PointTree.Intersect(gridRect, out Points, out ListofListTriangles); bool[] Added = new bool[_mapPoints.Length]; MappingPointList = new List<MappingGridVector2>(Points.Count * 2); List<List<MappingGridTriangle>> MappingTriangleList = new List<List<MappingGridTriangle>>(Points.Count * 2); //Add all the unique points bordering the requested rectangle for (int iPoint = 0; iPoint < Points.Count; iPoint++) { List<MappingGridTriangle> FoundTriangleList = ListofListTriangles[iPoint]; for (int iTri = 0; iTri < FoundTriangleList.Count; iTri++) { MappingGridTriangle Triangle = FoundTriangleList[iTri]; if (!Added[Triangle.N1]) { Added[Triangle.N1] = true; MappingPointList.Add(this._mapPoints[Triangle.N1]); MappingTriangleList.Add(this._TriangleList[Triangle.N1]); } if (!Added[Triangle.N2]) { Added[Triangle.N2] = true; MappingPointList.Add(this._mapPoints[Triangle.N2]); MappingTriangleList.Add(this._TriangleList[Triangle.N1]); } if (!Added[Triangle.N3]) { Added[Triangle.N3] = true; MappingPointList.Add(this._mapPoints[Triangle.N3]); MappingTriangleList.Add(this._TriangleList[Triangle.N1]); } } } return MappingPointList; }
/// <summary> /// Takes two transforms and transforms the control grid of this section into the control grid space of the passed transfrom. Requires control section /// of this transform to match mapped section of adding transform /// </summary> public void Add(GridTransform transform) { //We can't map if we don't have a triangle if (transform.mapPoints.Length < 3) return; //Temp: Ensure we know the edges this.CalculateEdges(); transform.BuildDataStructures(); //Reset boundaries since they will be changed _CachedControlBounds = new GridRectangle(double.MinValue, double.MinValue, 0, 0); _CachedMappedBounds = new GridRectangle(double.MinValue, double.MinValue, 0, 0); List<AddTransformThreadObj> threadObjList = new List<AddTransformThreadObj>(); List<ManualResetEvent> doneEvents = new List<ManualResetEvent>(); List<MappingGridVector2> newPoints = new List<MappingGridVector2>(mapPoints.Length); #if DEBUG List<GridVector2> mapPointList = new List<GridVector2>(newPoints.Count); #endif // Trace.WriteLine("Starting with " + mapPoints.Length + " points", "Geometry"); // List<MappingGridVector2> newPoints = new List<MappingGridVector2>(); // Trace.WriteLine("Started GridTransform.Add with " + mapPoints.Length.ToString() + " points", "Geometry"); //Search all mapping triangles and update control points, if they fall outside the grid then discard the triangle const int PointsPerThread = 4; for (int iPoint = 0; iPoint < this.mapPoints.Length; iPoint += PointsPerThread ) { //Create a series of points for the thread to process so they aren't constantly hitting the queue lock looking for new work. List<int> listPoints = new List<int>(PointsPerThread); for (int iAddPoint = iPoint; iAddPoint < iPoint + PointsPerThread; iAddPoint++) { //Don't add if the point is out of range if (iAddPoint >= this.mapPoints.Length) break; listPoints.Add(iAddPoint); } //MappingGridVector2 mapPoint = mapPoints[iPoint]; AddTransformThreadObj AddThreadObj = new AddTransformThreadObj(listPoints.ToArray(), this, transform); doneEvents.Add(AddThreadObj.DoneEvent); threadObjList.Add(AddThreadObj); /* MappingGridVector2 UnmappedPoint = mapPoints[iPoint]; MappingGridTriangle mapTri = transform.GetTransform(mapPoints[iPoint].ControlPoint); if (mapTri != null) { GridVector2 newControl = mapTri.Transform(UnmappedPoint.ControlPoint); newPoints.AddRange(new MappingGridVector2[] { new MappingGridVector2(newControl, UnmappedPoint.MappedPoint) }); List<MappingGridVector2> sortPoints = new List<MappingGridVector2>(newPoints); sortPoints.Sort(); for (int i = 1; i < sortPoints.Count; i++) { Debug.Assert(sortPoints[i - 1].ControlPoint != sortPoints[i].ControlPoint); } } else { //In this case we need to test each edge connecting this point to other points. //newPoints = new MappingGridVector2[0]; for(int i = 0; i < TriangleIndicies.Length; i += 3) { if(TriangleIndicies[i] == iPoint) { int[] EdgesIndicies = Array.Find<int>(this.TriangleIndicies, iPoint); } */ //For single threaded debug, comment out threadpool and uncomment AddThreadObj.ThreadPoolCallback line ThreadPool.QueueUserWorkItem(AddThreadObj.ThreadPoolCallback); // AddThreadObj.ThreadPoolCallback(null); //newPoints.AddRange(AddThreadObj.newPoints); //newPoints.Sort(); #if false for (int iTest = 1; iTest < newPoints.Count; iTest++) { Debug.Assert(newPoints[iTest - 1].ControlPoint != newPoints[iTest].ControlPoint); } for (int iMap = 0; iMap < AddThreadObj.newPoints.Length; iMap++) { mapPointList.Add(AddThreadObj.newPoints[iMap].MappedPoint); } mapPointList.Sort(); for (int iMap = 1; iMap < mapPointList.Count; iMap++) { Debug.Assert(GridVector2.Distance(mapPointList[iMap], mapPointList[iMap - 1]) > Global.epsilon); } #endif } //Wait for the threads to finish processing. There is a 64 handle limit for WaitAll so we wait on one at a time foreach (ManualResetEvent doneEvent in doneEvents) doneEvent.WaitOne(); newPoints.Clear(); foreach(AddTransformThreadObj obj in threadObjList) { if(obj.newPoints != null) newPoints.AddRange(obj.newPoints); } // Trace.WriteLine("Mapped " + newPoints.Count + " points", "Geometry"); #if false mapPointList.Clear(); for (int iMap = 0; iMap < newPoints.Count; iMap++) { mapPointList.Add(newPoints[iMap].MappedPoint); } mapPointList.Sort(); for (int iMap = 1; iMap < mapPointList.Count; iMap++) { Debug.Assert(GridVector2.Distance(mapPointList[iMap], mapPointList[iMap - 1]) > Global.epsilon); } #endif //Remove duplicates: In the case that a line on the warpingGrid passes through a point on the fixedGrid then both ends of the line will map the point and we will get a duplicate newPoints.Sort(); int iCompareStart = 0; for (int iTest = 1; iTest < newPoints.Count; iTest++) { // Debug.Assert(newPoints[iTest - 1].ControlPoint != newPoints[iTest].ControlPoint); //This is slow, but even though we sort on the X axis it doesn't mean a point that is not adjacent to the point on the list isn't too close for (int jTest = iCompareStart; jTest < iTest; jTest++) { if (GridVector2.Distance(newPoints[jTest].ControlPoint, newPoints[iTest].ControlPoint) <= Global.Epsilon) { newPoints.RemoveAt(iTest); iTest--; break; } //Optimization, since the array is sorted we don't need to compare points once a point is distant enough if (newPoints[iTest].ControlPoint.X - newPoints[jTest].ControlPoint.X > Global.Epsilon) { iCompareStart = jTest; } } } // Trace.WriteLine("Ended with " + newPoints.Count + " points", "Geometry"); this.mapPoints = newPoints.ToArray(); //Edges are build on mapPoints, so we need to remove them so they'll be recalculates _edges = null; //Other datastructures are dependent on edges, so minimize memory will delete them MinimizeMemory(); // Trace.WriteLine("Finished GridTransform.Add with " + newPoints.Count.ToString() + " points", "Geometry"); //Check whether these have been set yet or if I don't need to clear them again this.ControlSection = transform.ControlSection; }
private void btnOK_Click(object sender, EventArgs e) { double ROIWidth = (double)this.numWidth.Value * this.Downsample; double ROIHeight = (double)this.numHeight.Value * this.Downsample; this.Rect = new GridRectangle(new GridVector2((double)this.numX.Value - ROIWidth / 2, (double)this.numY.Value - ROIHeight / 2), ROIWidth, ROIHeight); ScreenshotForm.LastDownsampleValue = this.Downsample; this.IncludeOverlays = this.checkOverlays.Checked; //Write down the filename and remove the automatically appended number if needed ScreenshotForm.LastFileNamePrefix = System.IO.Path.GetFileNameWithoutExtension(textFilename.Text); string CaptureNumberString = "_" + ScreenshotForm.NextCaptureNumber.ToString("d03"); if (ScreenshotForm.LastFileNamePrefix.EndsWith(CaptureNumberString)) { int i = ScreenshotForm.LastFileNamePrefix.LastIndexOf(CaptureNumberString); ScreenshotForm.LastFileNamePrefix = ScreenshotForm.LastFileNamePrefix.Remove(i); } ScreenshotForm.LastFileNamePrefix = System.IO.Path.GetDirectoryName(textFilename.Text) + System.IO.Path.DirectorySeparatorChar + ScreenshotForm.LastFileNamePrefix; ScreenshotForm.NextCaptureNumber++; this.DialogResult = DialogResult.OK; this.Close(); //Try to create a descriptive text file matching the image name try { string dirname = System.IO.Path.GetDirectoryName(this.Filename); string basename = System.IO.Path.GetFileNameWithoutExtension(this.Filename); string MetaFilename = System.IO.Path.Combine(dirname, basename + ".txt"); using (System.IO.StreamWriter textFile = System.IO.File.CreateText(MetaFilename)) { double X = this.Rect.Left; double Y = this.Rect.Bottom; textFile.WriteLine("Filename:\t" + Filename); textFile.WriteLine("X: " + X.ToString() + "\tY: " + Y.ToString() + "\tZ: " + this._Z.ToString()); textFile.WriteLine("Width: " + Rect.Width.ToString() + "\tHeight: " + Rect.Height.ToString()); textFile.WriteLine("Downsample: " + Downsample.ToString()); } } catch (Exception except) { MessageBox.Show("Error creating meta-data file for screen capture:\n" + except.Message, "Error"); } }
/// <summary> /// Returns true if the specified tile is visible /// </summary> /// <param name="iX"></param> /// <param name="iY"></param> /// <returns></returns> private GridRectangle TileBorder(int iX, int iY, int Downsample) { GridRectangle TileBorder; double Width = this.TileSizeX * Downsample; double Height = this.TileSizeY * Downsample; double X = iX * Width; double Y = iY * Height; TileBorder = new GridRectangle(X, X+Width, Y, Y+Height); return TileBorder; }
private List<Tile> RecursiveVisibleTiles( GridRectangle VolumeVisibleBounds, GridRectangle SectionVisibleBounds, GridQuad VisibleQuad, int roundedDownsample) { GridInfo gridInfo = LevelToGridInfo[roundedDownsample]; int ScaledTileSizeX = this.TileSizeX * roundedDownsample; int ScaledTileSizeY = this.TileSizeX * roundedDownsample; //Figure out which grid locations are visible int iMinX = (int)Math.Floor(SectionVisibleBounds.Left / ScaledTileSizeX); int iMinY = (int)Math.Floor(SectionVisibleBounds.Bottom / ScaledTileSizeY); int iMaxX = (int)Math.Ceiling(SectionVisibleBounds.Right / ScaledTileSizeX); int iMaxY = (int)Math.Ceiling(SectionVisibleBounds.Top / ScaledTileSizeY); iMinX = iMinX < 0 ? 0 : iMinX; iMinY = iMinY < 0 ? 0 : iMinY; iMaxX = iMaxX > gridInfo.GridXDim ? gridInfo.GridXDim : iMaxX; iMaxY = iMaxY > gridInfo.GridYDim ? gridInfo.GridYDim : iMaxY; int ExpectedTileCount = (iMaxX - iMinX) * (iMaxY - iMinY); List<Tile> TilesToDraw = new List<Tile>(ExpectedTileCount); for (int iX = iMinX; iX < iMaxX; iX++) { for (int iY = iMinY; iY < iMaxY; iY++) { //Figure out if the tile would be visible GridRectangle tileBorder = TileBorder(iX, iY, roundedDownsample); if (tileBorder.Intersects(SectionVisibleBounds) == false) continue; //If we have a visble quad see if the tile intersects that too if (VisibleQuad != null) { if (VisibleQuad.Contains(tileBorder) == false) continue; } string UniqueID = Tile.CreateUniqueKey(Section.Number, "Grid to Volume", Name, roundedDownsample, this.TileTextureFileName(iX, iY)); // Trace.WriteLine(TextureFileName, "VolumeModel"); Tile tile = Global.TileCache.Fetch(UniqueID); if (tile == null) { //First create a new tile int MipMapLevels = 1; //No mip maps if (roundedDownsample == this.AvailableLevels[AvailableLevels.Length - 1]) MipMapLevels = 0; //Generate mipmaps for lowest res texture //PORT: string TextureCacheFileName = TileCacheName(iX, iY, roundedDownsample); int[] edges; // Trace.WriteLine(TextureFileName, "VolumeModel"); PositionNormalTextureVertex[] verticies = CalculateVerticies(iX, iY, roundedDownsample, out edges); string TextureFileName = TileFullPath(iX, iY, roundedDownsample); tile = Global.TileCache.ConstructTile(UniqueID, verticies, edges, TextureFileName, this.TileTextureCacheFileName(roundedDownsample, iX, iY), //PORT: TextureCacheFileName, this.Name, roundedDownsample, MipMapLevels); } TilesToDraw.Add(tile); } } return TilesToDraw; }
/// <summary> /// Return all the line segments visible in the passed bounds /// </summary> /// <param name="bounds"></param> /// <returns></returns> public StructureLink[] VisibleStructureLinks(GridRectangle bounds) { StructureLink[] LinkList = StructureLinksSearch.GetValues(bounds); return LinkList; }
/// <summary> /// This code was reverse engineered from original stos polynomial transform source /// </summary> /// <param name="parts"></param> /// <param name="pixelSpacing"></param> /// <param name="iFixedParameters"></param> /// <param name="iVariableParameters"></param> /// <param name="MappedBounds"></param> /// <returns></returns> public static List<MappingGridVector2> ParsePolyTransform(string[] parts, float pixelSpacing, int iFixedParameters, int iVariableParameters, GridRectangle MappedBounds) { List<MappingGridVector2> mappings = new List<MappingGridVector2>(); float MappedWidth = (float)MappedBounds.Width; float MappedHeight = (float)MappedBounds.Height; int numParams = System.Convert.ToInt32(parts[iVariableParameters +1]); //Skip two so we skip the "vp 5" part of the file and our indicies line up with Paul's code iFixedParameters += 2; iVariableParameters += 2; double uc = System.Convert.ToDouble(parts[iFixedParameters]); double vc = System.Convert.ToDouble(parts[iFixedParameters + 1]); double xmax = System.Convert.ToDouble(parts[iFixedParameters + 2]); double ymax = System.Convert.ToDouble(parts[iFixedParameters + 3]); uc = xmax / 2; vc = ymax / 2; double[] parameters = new double[numParams]; for(int iVP = 0; iVP < numParams; iVP++) { parameters[iVP] = System.Convert.ToDouble(parts[iVariableParameters + iVP]); } int gridHeight = 5; int gridWidth = 5; int NumPts = (int)(gridHeight * gridWidth); GridVector2[] Points = new GridVector2[NumPts]; for (int iY = 0; iY < gridHeight; iY++) { for (int iX = 0; iX < gridWidth; iX++) { double u = (xmax / (double)(gridWidth-1)) * (double)iX; double v = (ymax / (double)(gridHeight-1)) * (double)iY; double A = (u - uc) / xmax; double B = (v - vc) / ymax; //For some reason I am off by a factor of two: A *= 2; B *= 2; double[] P = new double[Dimensions + 1]; double[] Q = new double[Dimensions + 1]; for (int i = 0; i <= Dimensions; i++) { P[i] = Legendre.P[i](A); Q[i] = Legendre.P[i](B); } double Sa = 0.0; double Sb = 0.0; for (int i = 0; i <= Dimensions; i++) { for (int j = 0; j <= i; j++) { int k = i - j; double PjQk = P[j] * Q[k]; Sa += parameters[index_a(j, k)] * PjQk; Sb += parameters[index_b(j, k)] * PjQk; } } Points[(iY * gridWidth) + iX] = new GridVector2((xmax * Sa * pixelSpacing), (ymax * Sb * pixelSpacing)); } } for (int y = 0; y < gridHeight; y++) { for (int x = 0; x < gridWidth; x++) { int i = x + (y * gridWidth); GridVector2 controlPoint = Points[i]; GridVector2 mappedPoint = CoordinateFromGridPos(x, y, gridWidth, gridHeight, MappedWidth, MappedHeight); mappings.Add(new MappingGridVector2(controlPoint, mappedPoint)); } } return mappings; }
public GridRectangle RenderTargetBounds() { if (Device == null) return new GridRectangle(0, 0, 10, 10); //For debugging const int offset = 0; //GridVector2 TopLeft = ScreenToWorld(offset, offset); //GridVector2 BottomLeft = ScreenToWorld(offset, GraphicsDevice.Viewport.Height - offset); //GridVector2 TopRight = ScreenToWorld(GraphicsDevice.Viewport.Width - offset, offset); GridVector2 BottomLeft = Scene.ScreenToWorld(offset, Device.Viewport.Height - offset); GridVector2 TopRight = Scene.ScreenToWorld(Device.Viewport.Width - offset, offset); GridRectangle rect = new GridRectangle(BottomLeft, TopRight.X - BottomLeft.X, TopRight.Y - BottomLeft.Y); return rect; }
/// <summary> /// Returns a rectangle bounding the passed rectangles /// </summary> /// <param name="A"></param> /// <param name="B"></param> /// <returns></returns> public static GridRectangle Union(GridRectangle A, GridRectangle B) { double left = A.Left < B.Left ? A.Left : B.Left; double right = A.Right > B.Right ? A.Right : B.Right; double top = A.Top > B.Top ? A.Top : B.Top; double bottom = A.Bottom < B.Bottom ? A.Bottom : B.Bottom; return new GridRectangle(left, right, bottom, top); }
private static List<Location_CanvasViewModel> FindVisibleLocations(ICollection<Location_CanvasViewModel> locations, GridRectangle VisibleBounds) { GridCircle VisibleCircle = new GridCircle(VisibleBounds.Center, GridVector2.Distance(VisibleBounds.Center, new GridVector2(VisibleBounds.Left, VisibleBounds.Top))); List<Location_CanvasViewModel> listLocationsToDraw = new List<Location_CanvasViewModel>(locations.Count); foreach (Location_CanvasViewModel loc in locations) { if (loc == null) continue; if (!loc.VolumePositionHasBeenCalculated) continue; //Find out if we should draw the location if (loc.TypeCode == LocationType.CIRCLE) { if (VisibleCircle.Intersects(loc.VolumePosition, loc.Radius) == false) continue; } else if (loc.TypeCode == LocationType.POINT) { if (VisibleBounds.Contains(loc.VolumePosition) == false) continue; } else { Debug.Fail("Unknown location type"); } Structure ParentStructure = loc.Parent; if (ParentStructure == null) continue; if (ParentStructure.Type == null) continue; listLocationsToDraw.Add(loc); } return listLocationsToDraw; }
protected override void OnMouseUp(object sender, MouseEventArgs e) { if (oldMouse != null) { if (oldMouse.Button == MouseButtons.Left && this.CommandActive) { GridVector2 NewPosition = Parent.ScreenToWorld(e.X, e.Y); double Width = Math.Abs(NewPosition.X - Origin.X); double Height = Math.Abs(NewPosition.Y - Origin.Y); double X = Math.Min(Origin.X, NewPosition.X); double Y = Math.Min(Origin.Y, NewPosition.Y); MyRect = new GridRectangle(new GridVector2(X, Y), Width, Height); Execute(); this.Parent.Refresh(); } } base.OnMouseUp(sender, e); }
/// <summary> /// Returns a set of tiles which should be rendered in the order returned /// </summary> /// <param name="VisibleBounds">Visible region of the section</param> /// <returns></returns> public abstract TilePyramid VisibleTiles(GridRectangle VisibleBounds, double DownSample //PORT: bool AsynchTextureLoad );
public List<MappingGridVector2> IntersectingMappedRectangle(GridRectangle gridRect, bool IncludeAdjacent) { List<MappingGridVector2> foundPoints = IntersectingRectangle(gridRect, this.mapTriangles); if (!IncludeAdjacent) { for (int i = 0; i < foundPoints.Count; i++) { if (!gridRect.Contains(foundPoints[i].MappedPoint)) { foundPoints.RemoveAt(i); i--; } } } return foundPoints; }
public override TilePyramid VisibleTiles(GridRectangle VisibleBounds, double DownSample) { if (VolumeTransform != null) { GridQuad VisibleQuad = null; //Add any corners of the VisibleBounds that we can transform to the list of points List<MappingGridVector2> VisiblePoints = VisibleBoundsCorners(VolumeTransform, VisibleBounds); if (VisiblePoints.Count == 4) { VisiblePoints.Sort(new MappingGridVector2SortByMapPoints()); VisibleQuad = new GridQuad(VisiblePoints[0].MappedPoint, VisiblePoints[1].MappedPoint, VisiblePoints[2].MappedPoint, VisiblePoints[3].MappedPoint); } return VisibleTiles(VisibleBounds, VisibleQuad, DownSample); } else { return new TilePyramid(VisibleBounds); } }
/// <summary> /// Use this to set points and triangles so we don't have to run the delaunay algorithm. /// </summary> /// <param name="points"></param> /// <param name="triangleIndicies"></param> public void SetPointsAndTriangles(MappingGridVector2[] points, int[] triangleIndicies) { #if DEBUG //Check for duplicate points for (int i = 1; i < points.Length; i++) { Debug.Assert(points[i - 1].ControlPoint != points[i].ControlPoint, "Duplicate Points found in transform. This breaks Delaunay."); } #endif _mapPoints = points; _TriangleIndiciesCache = triangleIndicies; this._CachedMappedBounds = MappingGridVector2.CalculateMappedBounds(this.mapPoints); this._CachedControlBounds = MappingGridVector2.CalculateControlBounds(this.mapPoints); }