public PointCloudTileSourceEnumeratorChunk(PointCloudTile tile, BufferInstance buffer) { m_tile = tile; m_buffer = buffer; m_pointSizeBytes = m_tile.TileSet.TileSource.PointSizeBytes; m_dataPtr = buffer.DataPtr; m_dataEndPtr = m_dataPtr + m_tile.StorageSize; }
public void LoadTile(PointCloudTile tile, byte[] inputBuffer, int index) { if (tile == null) { throw new ArgumentNullException("tile"); } Open(); tile.ReadTile(m_inputStream, inputBuffer, index); }
public int Decompress(PointCloudTile tile, byte[] compressedBuffer, int count, byte[] uncompressedBuffer) { MemoryStream uncompressedStream = new MemoryStream(uncompressedBuffer); MemoryStream compressedStream = new MemoryStream(compressedBuffer, 0, count, false); using (SevenZipExtractor extractor = new SevenZipExtractor(compressedStream)) { extractor.ExtractFile(0, uncompressedStream); } return (int)uncompressedStream.Position; }
public int Decompress(PointCloudTile tile, byte[] compressedBuffer, int count, byte[] uncompressedBuffer) { MemoryStream compressedStream = new MemoryStream(compressedBuffer, 0, count, false); int uncompressedBytes = 0; using (ZipInputStream zipStream = new ZipInputStream(compressedStream, true)) { zipStream.GetNextEntry(); uncompressedBytes = zipStream.Read(uncompressedBuffer, 0, uncompressedBuffer.Length); } return uncompressedBytes; }
public int Compress(PointCloudTile tile, byte[] uncompressedBuffer, int count, byte[] compressedBuffer) { MemorableMemoryStream compressedStream = new MemorableMemoryStream(compressedBuffer); using (ZipOutputStream zipStream = new ZipOutputStream(compressedStream, true)) { zipStream.CompressionMethod = Ionic.Zip.CompressionMethod.Deflate; zipStream.CompressionLevel = Ionic.Zlib.CompressionLevel.BestSpeed; zipStream.PutNextEntry("a"); zipStream.Write(uncompressedBuffer, 0, count); } return (int)compressedStream.MaxPosition; }
public int Compress(PointCloudTile tile, byte[] uncompressedBuffer, int count, byte[] compressedBuffer) { SevenZipCompressor compressor = new SevenZipCompressor { CompressionMethod = SevenZip.CompressionMethod.Lzma2, CompressionLevel = CompressionLevel.Fast }; MemoryStream uncompressedStream = new MemoryStream(uncompressedBuffer, 0, count, false); // custom stream is required because the position is always 32 instead of the end of the stream MemorableMemoryStream compressedStream = new MemorableMemoryStream(compressedBuffer); compressor.CompressStream(uncompressedStream, compressedStream); return (int)compressedStream.MaxPosition; }
public bool MoveNext() { // check for cancel if (m_current != null && m_process != null && !m_process.Update(m_current)) { return(false); } if (m_tileEnumerator.MoveNext()) { PointCloudTile tile = m_tileEnumerator.Current; tile.ReadTile(m_stream, m_buffer.Data); m_current = new PointCloudTileSourceEnumeratorChunk(tile, m_buffer); return(true); } return(false); }
public unsafe void LoadTileGrid(PointCloudTile tile, BufferInstance inputBuffer, Grid <float> grid, Grid <int> quantizedGrid) { Open(); var quantizedExtent = tile.QuantizedExtent; double cellSizeX = (double)quantizedExtent.RangeX / grid.SizeX; double cellSizeY = (double)quantizedExtent.RangeY / grid.SizeY; #warning Why did I do FillVal it this way? //grid.FillVal = -1.0f; grid.Reset(); quantizedGrid.Reset(); byte *inputBufferPtr = inputBuffer.DataPtr; int bytesRead = tile.ReadTile(m_inputStream, inputBuffer.Data); byte *pb = inputBufferPtr; byte *pbEnd = inputBufferPtr + tile.StorageSize; while (pb < pbEnd) { var p = (SQuantizedPoint3D *)pb; pb += PointSizeBytes; var pixelX = (int)(((*p).X - quantizedExtent.MinX) / cellSizeX); var pixelY = (int)(((*p).Y - quantizedExtent.MinY) / cellSizeY); // max val for now, apparently if ((*p).Z > quantizedGrid.Data[pixelY, pixelX]) { quantizedGrid.Data[pixelY, pixelX] = (*p).Z; } } quantizedGrid.CorrectMaxOverflow(); quantizedGrid.CopyToUnquantized(grid, Quantization, Extent); }
public void LoadTile(PointCloudTile tile, byte[] inputBuffer, int index) { if (tile == null) throw new ArgumentNullException("tile"); Open(); tile.ReadTile(m_inputStream, inputBuffer, index); }
public static unsafe System.Windows.Media.Media3D.MeshGeometry3D LoadTilePointMesh(PointCloudTile tile, byte[] inputBuffer, double pointSize, int thinByFactor) { /*LoadTile(tile, inputBuffer); Extent3D distributionExtent = tile.Extent; Extent3D centeringExtent = Extent; Point3D centerOfMass = CenterOfMass; double xShift = -centeringExtent.MidpointX; double yShift = -centeringExtent.MidpointY; double zShift = -centerOfMass.Z; double halfPointSize = pointSize / 2; int thinnedTilePointCount = tile.PointCount / thinByFactor; // these values need to be changed from 4,6 to 8,36 if I test it out System.Windows.Media.Media3D.Point3DCollection positions = new System.Windows.Media.Media3D.Point3DCollection(thinnedTilePointCount * 4); System.Windows.Media.Media3D.Vector3DCollection normals = new System.Windows.Media.Media3D.Vector3DCollection(positions.Count); System.Windows.Media.Int32Collection indices = new System.Windows.Media.Int32Collection(tile.PointCount * 6); fixed (byte* inputBufferPtr = inputBuffer) { UQuantizedPoint3D* p = (UQuantizedPoint3D*)inputBufferPtr; for (int i = 0; i < tile.PointCount; i++) { if (!(i % thinByFactor == 0)) continue; // slow! Point3D point = Quantization.Convert(p[i]); double xC = point.X + xShift; double yC = point.Y + yShift; double zC = point.Z + zShift; int currentStartIndex = positions.Count; foreach (double y in new double[] { yC - halfPointSize, yC + halfPointSize }) { foreach (double x in new double[] { xC - halfPointSize, xC + halfPointSize }) { positions.Add(new System.Windows.Media.Media3D.Point3D(x, y, zC)); normals.Add(new System.Windows.Media.Media3D.Vector3D(0, 0, 1)); } } indices.Add(currentStartIndex + 0); indices.Add(currentStartIndex + 1); indices.Add(currentStartIndex + 3); indices.Add(currentStartIndex + 0); indices.Add(currentStartIndex + 3); indices.Add(currentStartIndex + 2); } } System.Windows.Media.Media3D.MeshGeometry3D geometry = new System.Windows.Media.Media3D.MeshGeometry3D(); geometry.Positions = positions; geometry.TriangleIndices = indices; geometry.Normals = normals; return geometry;*/ return null; }
public static unsafe System.Windows.Media.Media3D.MeshGeometry3D LoadTileMeshDelaunayIncremental(PointCloudTile tile, byte[] inputBuffer) { //Open(); //Extent3D extent = tile.Extent; //DelaunayPoint[] pointsToTriangulate = new DelaunayPoint[tile.PointCount]; //fixed (byte* inputBufferPtr = inputBuffer) //{ // UQuantizedPoint3D* p = (UQuantizedPoint3D*)inputBufferPtr; // int bytesRead = tile.ReadTile(m_inputStream, inputBuffer); // for (int i = 0; i < tile.PointCount; i++) // { // Point3D point = Quantization.Convert(p[i]); // pointsToTriangulate[i] = new DelaunayPoint( // (float)point.X, // (float)point.Y, // (float)point.Z, // i); // } //} //Delaunay2DIncremental triangulator = new Delaunay2DIncremental(); //triangulator.Initialize(extent, pointsToTriangulate.Length); //foreach (DelaunayPoint point in pointsToTriangulate) //{ // if (triangulator.Locate(point)) // triangulator.UpdateTriangle(point); //} //List<int> mesh = triangulator.FlushTriangles(); //System.Windows.Media.Media3D.Point3DCollection points = new System.Windows.Media.Media3D.Point3DCollection(pointsToTriangulate.Length); //for (int i = 0; i < pointsToTriangulate.Length; i++) // points.Add(new System.Windows.Media.Media3D.Point3D( // pointsToTriangulate[i].X - Extent.MidpointX, // pointsToTriangulate[i].Y - Extent.MidpointY, // pointsToTriangulate[i].Z - Extent.MidpointZ)); //System.Windows.Media.Int32Collection triangles = new System.Windows.Media.Int32Collection(mesh.Reverse<int>()); //System.Windows.Media.Media3D.MeshGeometry3D meshGeometry = new System.Windows.Media.Media3D.MeshGeometry3D(); //meshGeometry.Positions = points; //meshGeometry.TriangleIndices = triangles; //return meshGeometry; return null; }
public PointCloudTileTreeNodeLeaf(PointCloudTile tile) { m_tile = tile; }
private void UpdateCurrentTile(PointCloudTile tile) { foreach (System.Windows.Shapes.Rectangle rect in m_loadedTiles.Values) { rect.Stroke = System.Windows.Media.Brushes.DarkGray; } if (tile == null) return; var tilesToLoad = new List<PointCloudTile>(); //int pointsToLoad = 0; int radius = 4; int xMin = Math.Max(0, tile.Col - radius); int xMax = Math.Min(tile.Col + radius + 1, CurrentTileSource.TileSet.Cols); int yMin = Math.Max(0, tile.Row - radius); int yMax = Math.Min(tile.Row + radius + 1, CurrentTileSource.TileSet.Rows); for (int x = xMin; x < xMax; x++) { for (int y = yMin; y < yMax; y++) { PointCloudTile currentTile = CurrentTileSource.TileSet.GetTile(y, x); if (currentTile != null) { if (!m_loadedTiles.ContainsKey(currentTile)) { tilesToLoad.Add(currentTile); //pointsToLoad += currentTile.PointCount; System.Windows.Shapes.Rectangle rect = CreateTileRectangle(currentTile, previewImage, previewImageGrid); m_loadedTiles.Add(currentTile, rect); previewImageGraphicsGrid.Children.Add(rect); } else { System.Windows.Shapes.Rectangle rect = m_loadedTiles[currentTile]; if (tile.Equals(currentTile)) rect.Stroke = System.Windows.Media.Brushes.Red; else rect.Stroke = System.Windows.Media.Brushes.Blue; } } } } PointCloudTile[] loadedTiles = m_loadedTiles.Keys.ToArray(); SortByDistanceFromTile(loadedTiles, tile); Array.Reverse(loadedTiles); // drop loaded tiles that are the farthest from the center int totalAllowedPoints = MAX_BUFFER_SIZE_BYTES / CurrentTileSource.PointSizeBytes; int loadedPoints = loadedTiles.Sum(t => t.PointCount); int potentialTotalPoints = loadedPoints;// +pointsToLoad; if (potentialTotalPoints > totalAllowedPoints) { int pointsToDrop = potentialTotalPoints - totalAllowedPoints; int i = 0; while(pointsToDrop > 0 && i < loadedTiles.Length) { PointCloudTile currentTile = loadedTiles[i]; System.Windows.Shapes.Rectangle rect = m_loadedTiles[currentTile]; m_loadedTiles.Remove(currentTile); m_loadedTileBuffers.Remove(currentTile); // I don't know why I need to do this, but I can occasionally get a duplicate add below if I don't tilesToLoad.Remove(currentTile); previewImageGraphicsGrid.Children.Remove(rect); pointsToDrop -= currentTile.PointCount; ++i; } } var tilesToLoadOrdered = CurrentTileSource.TileSet.GetTileReadOrder(tilesToLoad); foreach (PointCloudTile currentTile in tilesToLoadOrdered) { // this will cause fragmentation problems, but it's just for demonstration byte[] inputBuffer = new byte[currentTile.PointCount * CurrentTileSource.PointSizeBytes]; CurrentTileSource.LoadTile(currentTile, inputBuffer); m_loadedTileBuffers.Add(currentTile, inputBuffer); } }
private void UpdateCurrentTile(PointCloudTile tile) { if (tile == null) return; List<PointCloudTile> tilesToLoad = new List<PointCloudTile>(); int pointsToLoad = 0; Model3DGroup emptyModelGroup = new Model3DGroup(); emptyModelGroup.Freeze(); bool isDirty = false; int radius = 2; int xMin = Math.Max(0, tile.Col - radius); int xMax = Math.Min(tile.Col + radius + 1, CurrentTileSource.TileSet.Cols); int yMin = Math.Max(0, tile.Row - radius); int yMax = Math.Min(tile.Row + radius + 1, CurrentTileSource.TileSet.Rows); for (int x = xMin; x < xMax; x++) { for (int y = yMin; y < yMax; y++) { PointCloudTile currentTile = CurrentTileSource.TileSet.GetTile(y, x); if (currentTile != null) { if (!m_loadedTiles.ContainsKey(currentTile)) { tilesToLoad.Add(currentTile); pointsToLoad += currentTile.PointCount; isDirty = true; } } } } PointCloudTile[] loadedTiles = m_loadedTiles.Keys.ToArray(); SortByDistanceFromTile(loadedTiles, tile); Array.Reverse(loadedTiles); // drop loaded tiles that are the farthest from the center int totalAllowedPoints = MAX_BUFFER_SIZE_BYTES / CurrentTileSource.PointSizeBytes; int loadedPoints = loadedTiles.Sum(t => t.PointCount); int potentialTotalPoints = loadedPoints + pointsToLoad; Dictionary<PointCloudTile, TileInfo3D> alteredTiles = new Dictionary<PointCloudTile, TileInfo3D>(); if (potentialTotalPoints > totalAllowedPoints) { int pointsToDrop = potentialTotalPoints - totalAllowedPoints; int i = 0; while (pointsToDrop > 0) { PointCloudTile currentTile = loadedTiles[i]; TileInfo3D tileInfo = m_tileInfo[currentTile]; GeometryModel3D model = m_loadedTiles[currentTile]; m_meshTileMap.Remove(model); m_loadedTiles.Remove(currentTile); //m_loadedTileBuffers.Remove(currentTile); // replace high-res tile with low-res geometry int modelIndex = tileInfo.Tile.ValidIndex; m_tileModelCollection[modelIndex] = tileInfo.LowResGeometry; // clear stitching m_stitchingModelCollection[modelIndex] = emptyModelGroup; tileInfo.ClearGeometry(); alteredTiles.Add(currentTile, tileInfo); pointsToDrop -= currentTile.PointCount; ++i; } } Jacere.Core.Geometry.Point3D centerOfMass = CurrentTileSource.CenterOfMass; PointCloudTile[] tilesToLoadArray = tilesToLoad.ToArray(); #warning sort so that disk reads are in order? or make a tile cache SortByDistanceFromTile(tilesToLoadArray, tile); foreach (PointCloudTile currentTile in tilesToLoadArray) { TileInfo3D tileInfo = m_tileInfo[currentTile]; CurrentTileSource.LoadTileGrid(currentTile, m_buffer, m_gridHighRes, m_quantizedGridHighRes); if (ENABLE_HEIGHT_EXAGGERATION) m_gridHighRes.Multiply(m_heightExaggerationFactor, (float)centerOfMass.Z); Jacere.Core.Geometry.Extent3D tileExtent = currentTile.Extent; MeshGeometry3D mesh = CurrentTileSource.GenerateMesh(m_gridHighRes, tileExtent); DiffuseMaterial material = new DiffuseMaterial(); if (USE_HIGH_RES_TEXTURE) { material.Brush = m_overviewTextureBrush; mesh.TextureCoordinates = MeshUtils.GeneratePlanarTextureCoordinates(mesh, m_overallCenteredExtent, MathUtils.ZAxis); } else { material.Brush = m_solidBrush; } material.Freeze(); GeometryModel3D geometryModel = new GeometryModel3D(mesh, material); geometryModel.Freeze(); // replace low-res tile with high-res geometry int modelIndex = tileInfo.Tile.ValidIndex; m_tileModelCollection[modelIndex] = geometryModel; // clear stitching m_stitchingModelCollection[modelIndex] = emptyModelGroup; tileInfo.UpdateGeometry(geometryModel, m_gridHighRes); alteredTiles.Add(currentTile, tileInfo); m_meshTileMap.Add(geometryModel, currentTile); m_loadedTiles.Add(currentTile, geometryModel); //m_loadedTileBuffers.Add(currentTile, inputBuffer); } // in the future, I could have a list of which tiles need to be checked for stitching updates // go through the stitching groups and replace any empty ones with the appropriate stitching if (ENABLE_STITCHING && isDirty) { PointCloudTile[] alteredTileArray = alteredTiles.Keys.ToArray(); foreach (PointCloudTile currentTile in alteredTileArray) { // this amount of clearing is excessive. I only want to clear one of the edges if (currentTile.Col < CurrentTileSource.TileSet.Cols - 1) { PointCloudTile adjacentTile = CurrentTileSource.TileSet.GetTile(currentTile.Row, currentTile.Col + 1); if (adjacentTile != null && m_tileInfo.ContainsKey(adjacentTile)) { TileInfo3D adjacentTileInfo = m_tileInfo[adjacentTile]; if (!alteredTiles.ContainsKey(adjacentTile)) alteredTiles.Add(adjacentTile, adjacentTileInfo); m_stitchingModelCollection[adjacentTileInfo.Tile.ValidIndex] = emptyModelGroup; adjacentTileInfo.UpdateStitching(null, null, TileStitchingEdge.Left); } } if (currentTile.Row < CurrentTileSource.TileSet.Rows - 1) { PointCloudTile adjacentTile = CurrentTileSource.TileSet.GetTile(currentTile.Row + 1, currentTile.Col); if (adjacentTile != null && m_tileInfo.ContainsKey(adjacentTile)) { TileInfo3D adjacentTileInfo = m_tileInfo[adjacentTile]; if (!alteredTiles.ContainsKey(adjacentTile)) alteredTiles.Add(adjacentTile, adjacentTileInfo); m_stitchingModelCollection[adjacentTileInfo.Tile.ValidIndex] = emptyModelGroup; adjacentTileInfo.UpdateStitching(null, null, TileStitchingEdge.Top); } } if (currentTile.Col < CurrentTileSource.TileSet.Cols - 1 && currentTile.Row < CurrentTileSource.TileSet.Rows - 1) { PointCloudTile adjacentTile = CurrentTileSource.TileSet.GetTile(currentTile.Row + 1, currentTile.Col + 1); if (adjacentTile != null && m_tileInfo.ContainsKey(adjacentTile)) { TileInfo3D adjacentTileInfo = m_tileInfo[adjacentTile]; if (!alteredTiles.ContainsKey(adjacentTile)) alteredTiles.Add(adjacentTile, adjacentTileInfo); m_stitchingModelCollection[adjacentTileInfo.Tile.ValidIndex] = emptyModelGroup; adjacentTileInfo.UpdateStitching(null, null, TileStitchingEdge.TopLeft); } } } foreach (KeyValuePair<PointCloudTile, TileInfo3D> kvp in alteredTiles) { int i = kvp.Value.Tile.ValidIndex; Model3DGroup stitchingGroup = m_stitchingModelCollection[i] as Model3DGroup; if (stitchingGroup.Children.Count == 0) { GeometryModel3D geometryModel = m_tileModelCollection[i] as GeometryModel3D; Model3DGroup newStitchingGroup = GenerateTileStitching(CurrentTileSource, kvp.Value); if (newStitchingGroup.Children.Count > 0) m_stitchingModelCollection[i] = newStitchingGroup; } } //for (int i = 0; i < m_stitchingModelCollection.Count; i++) //{ // Model3DGroup stitchingGroup = m_stitchingModelCollection[i] as Model3DGroup; // // this is an incorrect condition, but it won't be apparent until I get multi-res stitching // if (stitchingGroup.Children.Count < 3) // { // GeometryModel3D geometryModel = m_tileModelCollection[i] as GeometryModel3D; // PointCloudTile currentTile = m_meshTileMap[geometryModel]; // TileInfo3D currentTileInfo = m_tileInfo[currentTile]; // Model3DGroup newStitchingGroup = GenerateTileStitching(CurrentTileSource, currentTileInfo); // if (newStitchingGroup.Children.Count > 0) // m_stitchingModelCollection[i] = newStitchingGroup; // } //} } }
public int ReadLowResTile(PointCloudTile tile, byte[] buffer, int position) { // todo: get lowres points return(0); }
public static unsafe System.Windows.Media.Media3D.MeshGeometry3D LoadTilePointMesh(PointCloudTile tile, byte[] inputBuffer, double pointSize, int thinByFactor) { /*LoadTile(tile, inputBuffer); * * Extent3D distributionExtent = tile.Extent; * Extent3D centeringExtent = Extent; * Point3D centerOfMass = CenterOfMass; * * double xShift = -centeringExtent.MidpointX; * double yShift = -centeringExtent.MidpointY; * double zShift = -centerOfMass.Z; * * double halfPointSize = pointSize / 2; * * int thinnedTilePointCount = tile.PointCount / thinByFactor; * * // these values need to be changed from 4,6 to 8,36 if I test it out * System.Windows.Media.Media3D.Point3DCollection positions = new System.Windows.Media.Media3D.Point3DCollection(thinnedTilePointCount * 4); * System.Windows.Media.Media3D.Vector3DCollection normals = new System.Windows.Media.Media3D.Vector3DCollection(positions.Count); * System.Windows.Media.Int32Collection indices = new System.Windows.Media.Int32Collection(tile.PointCount * 6); * * fixed (byte* inputBufferPtr = inputBuffer) * { * UQuantizedPoint3D* p = (UQuantizedPoint3D*)inputBufferPtr; * * for (int i = 0; i < tile.PointCount; i++) * { * if (!(i % thinByFactor == 0)) * continue; * * // slow! * Point3D point = Quantization.Convert(p[i]); * double xC = point.X + xShift; * double yC = point.Y + yShift; * double zC = point.Z + zShift; * * int currentStartIndex = positions.Count; * * foreach (double y in new double[] { yC - halfPointSize, yC + halfPointSize }) * { * foreach (double x in new double[] { xC - halfPointSize, xC + halfPointSize }) * { * positions.Add(new System.Windows.Media.Media3D.Point3D(x, y, zC)); * normals.Add(new System.Windows.Media.Media3D.Vector3D(0, 0, 1)); * } * } * * indices.Add(currentStartIndex + 0); * indices.Add(currentStartIndex + 1); * indices.Add(currentStartIndex + 3); * * indices.Add(currentStartIndex + 0); * indices.Add(currentStartIndex + 3); * indices.Add(currentStartIndex + 2); * } * } * * System.Windows.Media.Media3D.MeshGeometry3D geometry = new System.Windows.Media.Media3D.MeshGeometry3D(); * geometry.Positions = positions; * geometry.TriangleIndices = indices; * geometry.Normals = normals; * * return geometry;*/ return(null); }
public static unsafe System.Windows.Media.Media3D.MeshGeometry3D LoadTileMeshDelaunayIncremental(PointCloudTile tile, byte[] inputBuffer) { //Open(); //Extent3D extent = tile.Extent; //DelaunayPoint[] pointsToTriangulate = new DelaunayPoint[tile.PointCount]; //fixed (byte* inputBufferPtr = inputBuffer) //{ // UQuantizedPoint3D* p = (UQuantizedPoint3D*)inputBufferPtr; // int bytesRead = tile.ReadTile(m_inputStream, inputBuffer); // for (int i = 0; i < tile.PointCount; i++) // { // Point3D point = Quantization.Convert(p[i]); // pointsToTriangulate[i] = new DelaunayPoint( // (float)point.X, // (float)point.Y, // (float)point.Z, // i); // } //} //Delaunay2DIncremental triangulator = new Delaunay2DIncremental(); //triangulator.Initialize(extent, pointsToTriangulate.Length); //foreach (DelaunayPoint point in pointsToTriangulate) //{ // if (triangulator.Locate(point)) // triangulator.UpdateTriangle(point); //} //List<int> mesh = triangulator.FlushTriangles(); //System.Windows.Media.Media3D.Point3DCollection points = new System.Windows.Media.Media3D.Point3DCollection(pointsToTriangulate.Length); //for (int i = 0; i < pointsToTriangulate.Length; i++) // points.Add(new System.Windows.Media.Media3D.Point3D( // pointsToTriangulate[i].X - Extent.MidpointX, // pointsToTriangulate[i].Y - Extent.MidpointY, // pointsToTriangulate[i].Z - Extent.MidpointZ)); //System.Windows.Media.Int32Collection triangles = new System.Windows.Media.Int32Collection(mesh.Reverse<int>()); //System.Windows.Media.Media3D.MeshGeometry3D meshGeometry = new System.Windows.Media.Media3D.MeshGeometry3D(); //meshGeometry.Positions = points; //meshGeometry.TriangleIndices = triangles; //return meshGeometry; return(null); }
public unsafe void LoadTileGrid(PointCloudTile tile, BufferInstance inputBuffer, Grid<float> grid, Grid<int> quantizedGrid) { Open(); var quantizedExtent = tile.QuantizedExtent; double cellSizeX = (double)quantizedExtent.RangeX / grid.SizeX; double cellSizeY = (double)quantizedExtent.RangeY / grid.SizeY; #warning Why did I do FillVal it this way? //grid.FillVal = -1.0f; grid.Reset(); quantizedGrid.Reset(); byte* inputBufferPtr = inputBuffer.DataPtr; int bytesRead = tile.ReadTile(m_inputStream, inputBuffer.Data); byte* pb = inputBufferPtr; byte* pbEnd = inputBufferPtr + tile.StorageSize; while (pb < pbEnd) { var p = (SQuantizedPoint3D*)pb; pb += PointSizeBytes; var pixelX = (int)(((*p).X - quantizedExtent.MinX) / cellSizeX); var pixelY = (int)(((*p).Y - quantizedExtent.MinY) / cellSizeY); // max val for now, apparently if ((*p).Z > quantizedGrid.Data[pixelY, pixelX]) quantizedGrid.Data[pixelY, pixelX] = (*p).Z; } quantizedGrid.CorrectMaxOverflow(); quantizedGrid.CopyToUnquantized(grid, Quantization, Extent); }
private void SortByDistanceFromTile(PointCloudTile[] tiles, PointCloudTile centerTile) { float[] distanceToCenter2 = new float[tiles.Length]; for (int i = 0; i < tiles.Length; i++) { distanceToCenter2[i] = (float)(Math.Pow(tiles[i].Col - centerTile.Col, 2) + Math.Pow(tiles[i].Row - centerTile.Row, 2)); } Array.Sort(distanceToCenter2, tiles); }
public int ReadLowResTile(PointCloudTile tile, byte[] buffer, int position) { // todo: get lowres points return 0; }
public TileInfo3D(PointCloudTile tile, GeometryModel3D lowResGeometry, Grid<float> lowResGrid) { Tile = tile; LowResGeometry = lowResGeometry; LowResGrid = lowResGrid; m_currentGeometry = LowResGeometry; m_currentGrid = LowResGrid; m_stitchingHasChanged = false; m_stitchingGeometry = new GeometryModel3D[3]; m_stitchingGrid = new Grid<float>[3]; }
private System.Windows.Shapes.Rectangle CreateTileRectangle(PointCloudTile tile, FrameworkElement image, Panel grid) { double containerWidth = image.ActualWidth; double containerHeight = image.ActualHeight; double imageLocationX = (grid.ActualWidth - containerWidth) / 2; double imageLocationY = (grid.ActualHeight - containerHeight) / 2; double tileRatioX = (double)tile.Col / (CurrentTileSource.TileSet.Cols); double tileRatioY = 1 - ((double)(tile.Row + 1) / (CurrentTileSource.TileSet.Rows)); double tileLocationX = imageLocationX + tileRatioX * containerWidth; double tileLocationY = imageLocationY + tileRatioY * containerHeight; double tileRatioWidth = 1.0 / (CurrentTileSource.TileSet.Cols); double tileRatioHeight = 1.0 / (CurrentTileSource.TileSet.Rows); System.Windows.Shapes.Rectangle rect = new System.Windows.Shapes.Rectangle(); rect.StrokeThickness = 1; rect.Stroke = System.Windows.Media.Brushes.Green; rect.HorizontalAlignment = System.Windows.HorizontalAlignment.Left; rect.VerticalAlignment = System.Windows.VerticalAlignment.Top; rect.Width = tileRatioWidth * containerWidth; rect.Height = tileRatioHeight * containerHeight; rect.Margin = new Thickness(tileLocationX, tileLocationY, 0, 0); return rect; }