Beispiel #1
0
        public static void WriteV3fArrayAsAara(string filePath, V3f[] elements, V2i sizeV)
        {
            var file = File.Open(filePath, FileMode.Create);

            using (var writer = new BinaryWriter(file, Encoding.UTF8))
            {
                string typeName   = "V3f";
                byte   dimensions = (byte)2;
                int[]  size       = { sizeV.X, sizeV.Y };

                writer.Write(typeName);
                writer.Write(dimensions);

                writer.Write(size[0]);
                writer.Write(size[1]);

                for (int i = 0; i < elements.Length; i++)
                {
                    writer.Write(elements[i].X);
                    writer.Write(elements[i].Y);
                    writer.Write(elements[i].Z);
                }

                writer.Flush();
            }
            file.Dispose();
        }
        public static C4b[] ComputeColorMap(V2i size)
        {
            var length     = size.X * size.Y;
            var indexArray = new C4b[length];

            var stepX = 255 / (double)size.X;
            var stepY = 255 / (double)size.Y;

            //var currColor = C4b.Black;
            for (int j = 0; j < size.Y; j++)
            {
                for (int i = 0; i < size.X; i++)
                {
                    int index = j * size.X + i;
                    var newR  = (byte)(stepX * i);
                    var newG  = (byte)(stepY * j);

                    indexArray[index]         = new C4b(newR, newG, (byte)128);
                    indexArray[index].Opacity = 255;
                }
            }

            indexArray[0]          = C4b.Red;
            indexArray[length - 1] = C4b.Blue;

            return(indexArray);
        }
        public static C4b[] DefaultColor(V2i size)
        {
            var length     = size.X * size.Y;
            var indexArray = new C4b[length].Set(C4b.White);

            return(indexArray);
        }
Beispiel #4
0
        public static int[] GetIndexArray(V2i size, List <int> invalidPoints)
        {
            if (invalidPoints != null)
            {
                return(OpcIndices.ComputeIndexArray(size, invalidPoints));
            }

            if (s_indexArrayTable == null)
            {
                s_indexArrayTable = new ConcurrentDictionary <V2i, int[]>();
            }

            lock (s_indexArrayTable)
            {
                int[] indices;
                s_indexArrayTable.TryGetValue(size, out indices);

                if (indices != null)
                {
                    return(indices);
                }
                else
                {
                    Report.Begin("Computing Index Array Table for {0}", size);
                    indices = OpcIndices.ComputeIndexArray(size, invalidPoints);
                    if (!s_indexArrayTable.ContainsKey(size))
                    {
                        s_indexArrayTable.TryAdd(size, indices);
                    }
                    Report.End();

                    return(indices);
                }
            }
        }
Beispiel #5
0
        /// <summary>
        /// Returns a subregion of an IEnumerable, which is expected to be a grid in the given resolution.
        /// </summary>
        /// <param name="origin">upper left corner in the subpatch</param>
        /// <param name="size">dimensions in number of entries</param>
        /// <param name="resolution">Resolution of the expected grid</param>
        public static IEnumerable <T> GetSubPatch <T>(this IEnumerable <T> self, V2i origin, V2i size, V2i resolution)
        {
            //Exception for now - think of good handling of the different cases
            //return empty grid
            if (origin.X >= resolution.X || origin.Y >= resolution.Y)
            {
                throw new NotImplementedException("requested origin outside of source grid");
            }

            //return full grid
            if (size.X >= resolution.X || size.Y >= resolution.Y)
            {
                throw new NotImplementedException("requested size bigger than source grid");
            }

            //return grid as big as possible
            if (origin.X + size.X >= resolution.X || origin.Y + size.Y >= resolution.Y)
            {
                throw new NotImplementedException("requested tile exceeds source grid boundaries");
            }

            int i          = -1;
            int firstIndex = origin.Y * resolution.X + origin.X;
            var last       = origin + size;
            int lastIndex  = (last.Y - 1) * resolution.X + last.X;

            int startRow = firstIndex;
            int endRow   = firstIndex + size.X;

            Report.Line(1, "Skipping {0} entries", firstIndex);
            foreach (var x in self)
            {
                i++;

                if (i < firstIndex)
                {
                    continue;
                }

                if (i >= startRow && i < endRow)
                {
                    if (i == endRow - 1)
                    {
                        //Console.WriteLine();
                        //Console.WriteLine("old start: {0},end: {1}", startRow, endRow);
                        startRow += resolution.X;
                        endRow   += resolution.X;
                        // Console.WriteLine("new start: {0},end: {1}", startRow, endRow);
                    }

                    yield return(x);
                }

                if (i == lastIndex)
                {
                    yield break;
                }
            }
        }
        public static int[] GetRowAsIndices(V2i size, int rowNumber)
        {
            var colInds = new List <int>();

            for (int i = 0; i < size.X; i++)
            {
                colInds.Add(size.X * rowNumber + i);
            }

            return(colInds.ToArray());
        }
        public static int[] GetColumnAsIndices(V2i size, int colNumber)
        {
            var colInds = new List <int>();

            for (int i = 0; i < size.Y; i++)
            {
                colInds.Add(size.X * i + colNumber);
            }

            return(colInds.ToArray());
        }
        public static int[] ComputeLineStripIndexArray(V2i size)
        {
            var indexArray = new int[(size.X * size.Y)];

            for (int j = 0; j < size.Y; j++)
            {
                for (int i = 0; i < size.X; i++)
                {
                    int index = j * size.X + i;
                    indexArray[index] = index;
                }
            }

            return(indexArray);
        }
Beispiel #9
0
        /// <summary>
        /// Creates normals for the OPC in opcBasePath and saves them as Normals.aara.
        /// </summary>
        public static void BuildNormals(OpcPaths opcPaths, bool overrideExisting = false, IObserver <Tup <float, string> > progress = null, CancellationToken cancelToken = default(CancellationToken))
        {
            var normalFileName = "Normals.aara";

            var posFiles = StorageConfig.GetDirectories(opcPaths.PatchesSubDir)
                           .SelectMany(x => StorageConfig.GetFiles(x))
                           .Where(fileWpath => fileWpath.EndsWith("Positions.aara", StringComparison.OrdinalIgnoreCase));

            foreach (var file in posFiles)
            {
                if (cancelToken.IsCancellationRequested)
                {
                    if (progress != null)
                    {
                        progress.OnNext(Tup.Create(0f, "Building normals cancelled."));
                        progress.OnCompleted();
                    }
                    cancelToken.ThrowIfCancellationRequested();
                }

                var normalsFilePath = Path.Combine(Path.GetDirectoryName(file), normalFileName);

                if (overrideExisting || !StorageConfig.FileExists(normalsFilePath))
                {
                    var posAara  = AaraData.FromFile(file);
                    var tileSize = new V2i(posAara.Size[0], posAara.Size[1]);

                    var posArray = AaraData.ConvertArrayToV3ds[posAara.DataTypeAsSymbol](posAara.LoadElements());

                    var invalidPoints = OpcIndices.GetInvalidPositions(posArray);
                    var indices       = OpcIndices.ComputeIndexArray(tileSize, invalidPoints);
                    var normals       = OpcIndices.GenerateVertexNormals(indices, posArray)
                                        .Select(p => p.ToV3f()).ToArray();

                    WriteV3fArrayAsAara(normalsFilePath, normals, tileSize);
                }

                if (progress != null)
                {
                    progress.OnNext(Tup.Create(1f / posFiles.Count(), ""));
                }
            }

            if (progress != null)
            {
                progress.OnCompleted();
            }
        }
Beispiel #10
0
        public static IPointSampleGrid2d GetSubPatch(this IPointSampleGrid2d self, V2i origin, V2i size)
        {
            var result = self.Positions.GetSubPatch(origin, size, self.Resolution);

            return(new PointSampleGrid2d(new PointSampleSet(result), size));

            //var posList = new List<V3d>();

            //var xOffset = origin.X;
            //var yOffset = origin.Y;

            //var stream = self.Positions;
            //var rowOrigin = yOffset * self.Resolution.X + xOffset;

            //var enumerator = stream.GetEnumerator();

            //Report.BeginTimed("construction subset of size {0}", size.ToString());
            //Report.BeginTimed("skipping {0} objects", rowOrigin);
            //for (int i = 0; i < rowOrigin; i++)
            //{
            //    enumerator.MoveNext();
            //}
            //Report.End();


            //for (int j = 0; j < size.Y; j++)
            //{
            //    //take a row and add it to poslist
            //    //move iterator to end of row
            //    for (int i = 0; i < size.X; i++)
            //    {
            //        posList.Add(enumerator.Current);
            //        enumerator.MoveNext();
            //    }

            //    //move iterator to begin of next row
            //    for (int i = 0; i < size.X; i++) enumerator.MoveNext();

            //    Report.Progress(posList.Count / (double)(size.X * size.Y));
            //    Report.Line();
            //}
            //Report.End("done");
        }
Beispiel #11
0
        /// <summary>
        /// Computes the neighbour indices in grid for a given position.
        /// </summary>
        private static List <int> GetGridNeighbourIndices(int x, int y, V2i tileSize)
        {
            var resultList = new List <int>();

            //North
            if (y > 0)
            {
                resultList.Add((y - 1) * tileSize.X + x);
            }

            //East
            if (x < tileSize.X - 1)
            {
                resultList.Add(y * tileSize.X + x + 1);
            }

            //South
            if (y < tileSize.Y - 1)
            {
                resultList.Add((y + 1) * tileSize.X + x);
            }

            //West
            if (x > 0)
            {
                resultList.Add(y * tileSize.X + x - 1);
            }

            if (x == tileSize.X - 1)
            {
                resultList.Add(y * tileSize.X + x - 1);
            }

            //if (resultList.Count == 0)
            //{
            //    resultList.Add((y - 1) * tileSize.X + x);
            //    resultList.Add(y * tileSize.X + x - 1);
            //}

            return(resultList);
        }
Beispiel #12
0
        public static int[] ComputeTriangleStripIndexArray(V2i size)
        {
            var numOfStrips       = size.Y - 1;
            var numOfSwapIndices  = (numOfStrips) * 2;
            var numOfStripIndices = numOfStrips * size.X * 2;
            var numOfIndices      = numOfSwapIndices + numOfStripIndices;

            var indexArray = new int[numOfIndices];

            int linItr = 0;

            for (int y = 0; y < size.Y - 1; y++)
            {
                for (int x = 0; x < size.X; x++)
                {
                    var indexUp   = size.X * y + x;
                    var indexDown = indexUp + size.X; //(size.X * (y + 1)) + x;

                    if (x == 0)
                    {
                        indexArray[linItr] = indexUp;
                        linItr++;
                    }

                    indexArray[linItr] = indexUp;
                    linItr++;
                    indexArray[linItr] = indexDown;
                    linItr++;

                    if (x == size.X - 1)
                    {
                        indexArray[linItr] = indexDown;
                        linItr++;
                    }
                }
            }

            return(indexArray);
        }
Beispiel #13
0
        public static int[] GetTriangleStripIndexArray(V2i size)
        {
            if (s_triangleStripIndexArrayTable == null)
            {
                s_triangleStripIndexArrayTable = new ConcurrentDictionary <V2i, int[]>();
            }

            int[] indices;
            s_triangleStripIndexArrayTable.TryGetValue(size, out indices);

            try
            {
                if (indices != null)
                {
                    return(indices);
                }
                else
                {
                    indices = OpcIndices.ComputeTriangleStripIndexArray(size);
                    s_triangleStripIndexArrayTable.TryAdd(size, indices);

                    return(indices);
                }
            }
            catch (ArgumentException)
            {
                return(s_triangleStripIndexArrayTable[size]);
            }

            //if (s_triangleStripIndexArrayTable.ContainsKey(size))
            //    return s_triangleStripIndexArrayTable[size];
            //else
            //{
            //    s_triangleStripIndexArrayTable.Add(size, OpcTile.ComputeTriangleStripIndexArray(size));
            //    return s_triangleStripIndexArrayTable[size];
            //}
        }
Beispiel #14
0
        public static int[] ComputeIndices(V2i size, IEnumerable <int> invalidPoints, V3f[] points, float maxTriangleSize)
        {
            var indexArray = new int[(size.X - 1) * (size.Y - 1) * 6];

            int k = 0;

            var  invalidDict = invalidPoints.ToDictionary(n => n);
            int  a1, b1, c1;
            int  a2, b2, c2;
            var  indices           = new List <int>();
            bool invalidFace       = false;
            int  counter           = 0;
            int  oversized_counter = 0;

            for (int y = 0; y < size.Y - 1; y++)
            {
                for (int x = 0; x < size.X - 1; x++)
                {
                    a1 = y * size.X + x;
                    b1 = (y + 1) * size.X + x;
                    c1 = y * size.X + x + 1;

                    a2 = y * size.X + x + 1;
                    b2 = (y + 1) * size.X + x;
                    c2 = (y + 1) * size.X + x + 1;

                    indices.Clear();
                    indices.Add(a1); indices.Add(b1); indices.Add(c1);
                    indices.Add(a2); indices.Add(b2); indices.Add(c2);

                    invalidFace = indices.Select(n => n).Where(m => invalidDict.ContainsKey(m)).ToList().Count() > 0;

                    if (invalidFace)
                    {
                        //Console.WriteLine("Invalid Face Found");
                        counter++;
                        k += 6;
                        continue;
                    }

                    if (!IsOversizedTriangle(points, a1, b1, c1, maxTriangleSize))
                    //if (!IsOversizedTriangleSideRatio(points, a1, b1, c1, maxTriangleSize))
                    {
                        indexArray[k]     = a1;
                        indexArray[k + 1] = b1;
                        indexArray[k + 2] = c1;
                    }
                    else
                    {
                        oversized_counter++;
                    }

                    if (!IsOversizedTriangle(points, a2, b2, c2, maxTriangleSize))
                    //if (!IsOversizedTriangleSideRatio(points, a2, b2, c2, maxTriangleSize))
                    {
                        indexArray[k + 3] = a2;
                        indexArray[k + 4] = b2;
                        indexArray[k + 5] = c2;
                    }
                    else
                    {
                        oversized_counter++;
                    }


                    k += 6;
                }
            }

            if (counter > 0)
            {
                Report.Line(5, "Invalid faces found: " + counter);
            }
            return(indexArray.ToArray());
        }
Beispiel #15
0
        public static int[] ComputeIndexArray(V2i size, IEnumerable <int> invalidPoints)
        {
            var indexArray = new int[(size.X - 1) * (size.Y - 1) * 6];

            int k = 0;

            bool hasInvalids = invalidPoints != null;

            #region no invalids
            if (!hasInvalids)
            {
                for (int y = 0; y < size.Y - 1; y++)
                {
                    for (int x = 0; x < size.X - 1; x++)
                    {
                        indexArray[k]     = y * size.X + x;
                        indexArray[k + 1] = (y + 1) * size.X + x;
                        indexArray[k + 2] = y * size.X + x + 1;

                        indexArray[k + 3] = y * size.X + x + 1;
                        indexArray[k + 4] = (y + 1) * size.X + x;
                        indexArray[k + 5] = (y + 1) * size.X + x + 1;

                        k += 6;
                    }
                }

                return(indexArray.ToArray());
            }
            #endregion
            #region has invalids
            else
            {
                var  invalidDict = invalidPoints.ToDictionary(n => n);
                int  a1, b1, c1;
                int  a2, b2, c2;
                var  indices     = new List <int>();
                bool invalidFace = false;
                int  counter     = 0;

                for (int y = 0; y < size.Y - 1; y++)
                {
                    for (int x = 0; x < size.X - 1; x++)
                    {
                        a1 = y * size.X + x;
                        b1 = (y + 1) * size.X + x;
                        c1 = y * size.X + x + 1;

                        a2 = y * size.X + x + 1;
                        b2 = (y + 1) * size.X + x;
                        c2 = (y + 1) * size.X + x + 1;

                        indices.Clear();
                        indices.Add(a1); indices.Add(b1); indices.Add(c1);
                        indices.Add(a2); indices.Add(b2); indices.Add(c2);

                        invalidFace = indices.Select(n => n).Where(m => invalidDict.ContainsKey(m)).ToList().Count() > 0;

                        if (invalidFace)
                        {
                            //Console.WriteLine("Invalid Face Found");
                            counter++;
                            k += 6;
                            continue;
                        }

                        indexArray[k]     = a1;
                        indexArray[k + 1] = b1;
                        indexArray[k + 2] = c1;

                        indexArray[k + 3] = a2;
                        indexArray[k + 4] = b2;
                        indexArray[k + 5] = c2;

                        k += 6;
                    }
                }

                if (counter > 0)
                {
                    Report.Line(5, "Invalid faces found: " + counter);
                }
                return(indexArray.ToArray());
            }
            #endregion
        }
Beispiel #16
0
 public static int[] ComputeTriangleStripIndexArray(V2i size, List <int> invalidPoints)
 {
     return(null);
 }
 public void Write(V2i x)
 {
     Write(x.X); Write(x.Y);
 }
Beispiel #18
0
 //First
 public static int[] GetFirstColumnAsIndices(V2i size)
 {
     return(GetColumnAsIndices(size, 0));
 }
Beispiel #19
0
 public static int[] GetLastRowAsIndices(V2i size)
 {
     return(GetRowAsIndices(size, size.Y - 1));
 }
        /// <summary>
        /// Loads VertexGeometry from aara files. Beware: add Local2Global node for global space.
        /// </summary>
        /// <param name="positions">Raw positions, read from aara files for possible further processing.</param>
        /// <param name="dataType">DataType of positions.</param>
        /// <returns>Vertex Geometry in local OPC space.</returns>
        public static VertexGeometry LoadPatch(PatchFileInfo info, string basePath, PositionsType posType, out Array positions, out Symbol dataType,
                                               bool loadNormals = true, bool loadTexCoords = true, bool loadDiffTex = true, bool loadHueTex = true, float maxTriangleSize = float.PositiveInfinity, bool loadAsDoubles = false)
        {
            var vg = new VertexGeometry(GeometryMode.TriangleList);

            positions = null;

            // load metadata
            var aara3dPos = AaraData.FromFile(
                Path.Combine(basePath, posType == PositionsType.V3dPositions
                ? info.Positions : info.Positions2d));

            dataType = aara3dPos.DataTypeAsSymbol;

            var resolution = new V2i(aara3dPos.Size);

            if (resolution.AnySmaller(2))
            {
                Report.Warn("ignoring patch {0} due to invalid gridresolution {1}", basePath, resolution);
                return(null);
            }

            // load positions
            positions = aara3dPos.LoadElements();
            var positions3d = loadAsDoubles ? positions : AaraData.ConvertArrayToV3fs[aara3dPos.DataTypeAsSymbol](positions);

            //var positionsV3 = loadAsDoubles ?
            //    (Array)AaraData.ConvertArrayToV3ds[aara3dPos.DataTypeAsSymbol](positions) :
            //    (Array);

            vg.Positions = positions3d;

            var p = AaraData.ConvertArrayToV3fs[aara3dPos.DataTypeAsSymbol](positions);

            // calculate indices
            var invalidPoints = OpcIndices.GetInvalidPositions(p);

            // limit triangle size
            if ((maxTriangleSize < float.PositiveInfinity) && (maxTriangleSize > 0.000001f))
            {
                vg.Indices = OpcIndices.ComputeIndexArray(resolution, invalidPoints.ToList(), p, maxTriangleSize);
            }
            else
            {
                vg.Indices = OpcIndices.ComputeIndexArray(resolution, invalidPoints.ToList());
            }

            // load normals
            if (loadNormals)
            {
                var normalPath = Path.Combine(basePath, "Normals.aara");
                if (StorageConfig.FileExists(normalPath))
                {
                    var normals   = AaraData.FromFile(normalPath);
                    var normals3d = AaraData.ConvertArrayToV3fs[normals.DataTypeAsSymbol](normals.LoadElements());
                    vg.Normals = normals3d;
                }
            }

            // load coordinates
            vg.Coordinates = new CoordinatesMap();
            if (loadTexCoords)
            {
                var coordPath   = Path.Combine(basePath, info.Coordinates.First());
                var coordinates = AaraData.FromFile(coordPath).LoadElements() as V2f[];
                vg.Coordinates[VertexGeometry.Property.DiffuseColorCoordinates] = coordinates;
            }

            // load textures
            vg.Textures = new TexturesMap();
            if (loadDiffTex)
            {
                var texFile = Path.ChangeExtension(info.Textures.First(), ".dds");
                var texPath = Path.GetFullPath(Path.Combine(basePath, @"..\..\images", texFile));

                if (StorageConfig.FileExists(texPath))
                {
                    var img = Convertible.FromFile(texPath);

                    vg.Textures[VertexGeometry.Property.DiffuseColorTexture] =
                        new Aardvark.Rendering.Texture(img)
                    {
                        ForceImmediateUpload = false
                    };
                }
            }
            if (loadHueTex)
            {
                vg.Textures[VertexGeometry.Property.LightMapTexture] =
                    new Aardvark.Rendering.Texture(Resources.HueColorMap.Convertible());
            }

            return(vg);
        }
        /// <summary>
        /// Computes the number of levels of a bottom-up hierarchy built on a grid of tiled elements. It is assumed
        /// that the root (top) of the hierarchy finally consists of one single tile.
        /// </summary>
        public static int ComputeHierarchyDepth(V2i gridSize)
        {
            var depth = System.Math.Log(System.Math.Max(gridSize.X, gridSize.Y), 2);

            return(System.Math.Ceiling(depth).ToInt());
        }
        static void Main(string[] args)
        {
            Aardvark.Base.Aardvark.Init(); // PixImage DevIL init

            var device = new Device();

            Report.Line("Version={0}", device.Version);
            Report.Line("RayMaskSupported={0}", device.RayMaskSupported);
            Report.Line("FilterFunctionSupported={0}", device.FilterFunctionSupported);

            var geos = new[]
            {
                new EmbreeIndexedGeometry(device,
                                          IndexedGeometryPrimitives.Sphere.solidPhiThetaSphere(new Sphere3d(V3d.OOO, 0.5), 1200, new C4b(160, 120, 190))),
                //new EmbreeIndexedGeometry(device,
                //    IndexedGeometryPrimitives.Quad.solidQuadrangle(V3d.OOO, V3d.IOO, V3d.IOI, V3d.OOI, new C4b(255, 255, 255), V3d.OIO)),
                //new EmbreeIndexedGeometry(device,
                //    IndexedGeometryPrimitives.Box.solidBox(new Box3d(V3d.OOO, V3d.III), new C4b(240, 150, 220))),
                //new EmbreeIndexedGeometry(device,
                //    IndexedGeometryPrimitives.Cone.solidCone(V3d.OOO, V3d.OOI, 1.0, 0.25, 12, new C4b(120, 130, 170))),
                //new EmbreeIndexedGeometry(device,
                //    IndexedGeometryPrimitives.Cylinder.solidCylinder(V3d.OOO, V3d.OOI, 1.0, 0.25, 0.15, 16, new C4b(250, 100, 140))),
                //new EmbreeIndexedGeometry(device,
                //    IndexedGeometryPrimitives.Torus.solidTorus(new Torus3d(V3d.OOO, V3d.OOI, 0.8, 0.2), new C4b(200, 180, 255), 12, 8)),
            };

            Report.Line("TriangleCount: {0}", geos.Sum(x => x.IndexedGeometry.FaceCount));

            var scene = new Scene(device, RTCBuildQuality.High, false);

            Report.BeginTimed("Create Scene");
            var geoMap = new Dictionary <uint, EmbreeIndexedGeometry>();

            // geometries with absolute transformation
            foreach (var g in geos)
            {
                geoMap.Add(scene.Attach(g.EmbreeGeometry), g);
            }

            //// instanced geometries with transformation matrix
            //foreach (var g in geos)
            //{
            //    var gi = new GeometryInstance(device, g.EmbreeGeometry, Affine3f.Identity);
            //    geoMap.Add(scene.Attach(gi), g);
            //}

            scene.Commit();
            Report.End();

            var cam = new CameraViewWithSky();

            cam.Location = V3d.III * 0.8;
            cam.LookAt(V3d.OOO);

            var vpSize = new V2i(3840, 2160);
            var proj   = new CameraProjectionPerspective(60, 0.1, 10, vpSize.X / (double)vpSize.Y);

            var pix = RenderSimple(scene, vpSize.X, vpSize.Y, cam.ViewTrafo, proj.ProjectionTrafo, geoMap);

            device.Dispose();

            var file = "C:\\Debug\\Embree.png";

            pix.SaveAsImage(file);

            //Process.Start(file);
        }
Beispiel #23
0
 /// <summary>Computes MD5 hash of given data.</summary>
 public static Guid ComputeMd5Hash(this V2i x)
 => ComputeMd5Hash(bw => { bw.Write(x.X); bw.Write(x.Y); });
Beispiel #24
0
 /// <summary>
 /// Compute index array to triangulate an ordered point set with
 /// a resolution of size.x X size.y
 /// </summary>
 /// <param name="size">V2i specifying number of points
 /// in x and y direction respectively</param>
 /// <returns>index array</returns>
 public static int[] ComputeIndexArray(V2i size)
 {
     return(ComputeIndexArray(size, null));
 }
Beispiel #25
0
 public static int[] GetIndexArray(V2i size)
 {
     return(GetIndexArray(size, null));
 }
Beispiel #26
0
 public static System.Drawing.Point ToPoint(this V2i p)
 {
     return(new System.Drawing.Point(p.X, p.Y));
 }
Beispiel #27
0
 public static int[] GetFirstRowAsIndices(V2i size)
 {
     return(GetRowAsIndices(size, 0));
 }
Beispiel #28
0
 public static System.Drawing.Size ToSize(this V2i v)
 {
     return(new System.Drawing.Size(v.X, v.Y));
 }
Beispiel #29
0
 //Last
 public static int[] GetLastColumnAsIndices(V2i size)
 {
     return(GetColumnAsIndices(size, size.X - 1));
 }