Geometry

Namespace: SharpDX.Direct2D1
We found 10 examples in language CSharp for this search. You will see 48 fragments of code.

            public IGeometry Edit(IGeometry geometry, IGeometryFactory factory)
            {
                return geometry;
            }

using System;
using GeoAPI.Geometries;

namespace GeoAPI.IO
{
    /// <summary>
    /// Lightweight class that handles OGC Geometry type declaration
    /// </summary>
    [CLSCompliant(false)]
    public struct GeometryType
    {
        /// <summary>
        /// Initializes this instance
        /// </summary>
        /// <param name="geometryType">The value describing the <see cref="GeometryType"/></param>
        public GeometryType(uint geometryType)
        {
            _geometrytype = geometryType;
        }

        /// <summary>
        /// Inititalizes this instance based on a geometry and an Ordinates flag.
        /// </summary>
        /// <param name="geometry">The geometry.</param>
        /// <param name="ordinates">The ordinates flag.</param>
        public GeometryType(IGeometry geometry, Ordinates ordinates)
            : this(geometry.OgcGeometryType, ordinates, geometry.SRID >= 0)
        {
        }

        /// <summary>
        /// Inititalizes this instance based on an <see cref="OgcGeometryType"/>
        /// </summary>
        /// <param name="ogcGeometryType">The OGC geometry type</param>
        public GeometryType(OgcGeometryType ogcGeometryType)
            : this(ogcGeometryType, Ordinates.XY, false)
        {

        }

        /// <summary>
        /// Inititalizes this instance based on an <see cref="OgcGeometryType"/> and an SRID indicator
        /// </summary>
        /// <param name="ogcGeometryType">The OGC geometry type</param>
        /// <param name="hasSrid">Indicator if a SRID is supplied.</param>
        public GeometryType(OgcGeometryType ogcGeometryType, bool hasSrid)
            :this(ogcGeometryType, Ordinates.XY, hasSrid)
        {
        }

        /// <summary>
        /// Inititalizes this instance based on an <see cref="OgcGeometryType"/> and an SRID indicator
        /// </summary>
        /// <param name="ogcGeometryType">The OGC geometry type</param>
        /// <param name="ordinates">The ordinates flag.</param>
        /// <param name="hasSrid">Indicator if a SRID is supplied.</param>
        public GeometryType(OgcGeometryType ogcGeometryType, Ordinates ordinates, bool hasSrid)
        {
            _geometrytype = (uint) ogcGeometryType;
            
            if ((ordinates & Ordinates.Z) != 0)
            {
                HasWkbZ = true;
                HasEwkbM = true;
            }

            if ((ordinates & Ordinates.M) != 0)
            {
                HasWkbZ = true;
                HasEwkbM = true;
            }

            HasEwkbSrid = hasSrid;
        }

        private uint _geometrytype;

        /// <summary>
        /// Gets or sets the base geometry type
        /// </summary>
        public OgcGeometryType BaseGeometryType
        {
            get
            {
                //Leave out Ewkb flags
                var val = _geometrytype & 0xffffff;
                if (val > 2000) val -= 2000;
                if (val > 1000) val -= 1000;
                return (OgcGeometryType) val;
            }
            set
            {
                var ewkbFlags = _geometrytype & EwkbFlags;
                var newGeometryType = (uint) value;
                if (HasWkbZ) newGeometryType += 1000;
                if (HasWkbM) newGeometryType += 2000;
                _geometrytype = ewkbFlags | newGeometryType;
            }
        }

        /// <summary>
        /// Gets the OGC Well-Known-Binary type code
        /// </summary>
        public int WkbGeometryType
        {
            get { return (int) (_geometrytype & 0x1ffffff); }
        }

        /// <summary>
        /// Gets the PostGIS Enhanced Well-Known-Binary type code
        /// </summary>
        public int EwkbWkbGeometryType
        {
            get
            {
                return (int) ((uint) BaseGeometryType | (_geometrytype & 0xfe000000));
            }
        }

        /// <summary>
        /// Gets or sets whether z-ordinate values are stored along with the geometry.
        /// </summary>
        public bool HasZ { get { return HasWkbZ | HasEwkbZ; } }
        
        /// <summary>
        /// Gets or sets whether m-ordinate values are stored along with the geometry.
        /// </summary>
        public bool HasM { get { return HasWkbM | HasEwkbM; } }

        /// <summary>
        /// Gets whether SRID value is stored along with the geometry.
        /// </summary>
        public bool HasSrid { get { return HasEwkbSrid; } }

        /// <summary>
        /// Gets or sets whether z-ordinate values are stored along with the geometry.
        /// </summary>
        public bool HasWkbZ
        {
            get { return (_geometrytype/1000) == 1; }
            set
            {
                if (value == HasWkbZ)
                    return;
                if (HasWkbZ)
                    _geometrytype -= 1000;
                else
                    _geometrytype += 1000;

            }
        }

        /// <summary>
        /// Gets or sets whether m-ordinate values are stored along with the geometry.
        /// </summary>
        public bool HasWkbM
        {
            get { return (_geometrytype/2000) == 2; }
            set
            {
                if (value == HasWkbM)
                    return;
                if (HasWkbM)
                    _geometrytype -= 2000;
                else
                    _geometrytype += 2000;

            }
        }

        #region PostGis EWKB/EWKT
        
        private const uint EwkbZFlag = 0x8000000;
        private const uint EwkbMFlag = 0x4000000;
        private const uint EwkbSridFlag = 0x2000000;

        private const uint EwkbFlags = EwkbZFlag | EwkbMFlag | EwkbSridFlag;

        /// <summary>
        /// Gets or sets whether z-ordinates are stored along with the geometry.
        /// <para>PostGis EWKB format.</para>
        /// </summary>
        public bool HasEwkbZ
        {
            get { return (_geometrytype & EwkbZFlag) == EwkbZFlag; }
            set
            {
                var gt = _geometrytype & (~EwkbZFlag);
                if (value)
                    gt = _geometrytype | EwkbZFlag;
                _geometrytype = gt;
            }
        }

        /// <summary>
        /// Gets or sets whether z-ordinates are stored along with the geometry.
        /// <para>PostGis EWKB format.</para>
        /// </summary>
        public bool HasEwkbM
        {
            get { return (_geometrytype & EwkbMFlag) == EwkbMFlag; }
            set
            {
                var gt = _geometrytype & (~EwkbMFlag);
                if (value)
                    gt = _geometrytype | EwkbMFlag;
                _geometrytype = gt;
            }
        }

        /// <summary>
        /// Gets or sets whether z-ordinates are stored along with the geometry.
        /// <para>PostGis EWKB format.</para>
        /// </summary>
        public bool HasEwkbSrid
        {
            get { return (_geometrytype & EwkbSridFlag) == EwkbSridFlag; }
            set { 
                var gt = _geometrytype & (~EwkbSridFlag);
                if (value)
                    gt = _geometrytype | EwkbSridFlag;
                _geometrytype = gt;
            }
        }

        #endregion
    }
}

        public int CreateAudioGeometry(out IntPtr geometry)
        {
            return ovrAudio_CreateAudioGeometry(context, out geometry);
        }
        public int DestroyAudioGeometry(IntPtr geometry)
        {
            return ovrAudio_DestroyAudioGeometry(geometry);
        }
        public int AudioGeometrySetTransform(IntPtr geometry, float[] matrix4x4)
        {
            return ovrAudio_AudioGeometrySetTransform(geometry, matrix4x4);
        }
        public int AudioGeometryGetTransform(IntPtr geometry, out float[] matrix4x4)
        {
            return ovrAudio_AudioGeometryGetTransform(geometry, out matrix4x4);
        }
        public int AudioGeometryWriteMeshFile(IntPtr geometry, string filePath)
        {
            return ovrAudio_AudioGeometryWriteMeshFile(geometry, filePath);
        }
        public int AudioGeometryReadMeshFile(IntPtr geometry, string filePath)
        {
            return ovrAudio_AudioGeometryReadMeshFile(geometry, filePath);
        }

        public int CreateAudioGeometry(out IntPtr geometry)
        {
            return ovrAudio_CreateAudioGeometry(context, out geometry);
        }
        public int DestroyAudioGeometry(IntPtr geometry)
        {
            return ovrAudio_DestroyAudioGeometry(geometry);
        }
        public int AudioGeometrySetTransform(IntPtr geometry, float[] matrix4x4)
        {
            return ovrAudio_AudioGeometrySetTransform(geometry, matrix4x4);
        }
        public int AudioGeometryGetTransform(IntPtr geometry, out float[] matrix4x4)
        {
            return ovrAudio_AudioGeometryGetTransform(geometry, out matrix4x4);
        }
        public int AudioGeometryWriteMeshFile(IntPtr geometry, string filePath)
        {
            return ovrAudio_AudioGeometryWriteMeshFile(geometry, filePath);
        }
        public int AudioGeometryReadMeshFile(IntPtr geometry, string filePath)
        {
            return ovrAudio_AudioGeometryReadMeshFile(geometry, filePath);
        }

            public static int CreateAudioGeometry(out IntPtr geometry)
            {
                return ovrAudio_CreateAudioGeometry(context, out geometry);
            }
            public static int DestroyAudioGeometry(IntPtr geometry)
            {
                return ovrAudio_DestroyAudioGeometry(geometry);
            }
            public static int AudioGeometrySetTransform(IntPtr geometry, float[] matrix4x4)
            {
                return ovrAudio_AudioGeometrySetTransform(geometry, matrix4x4);
            }
            public static int AudioGeometryGetTransform(IntPtr geometry, out float[] matrix4x4)
            {
                return ovrAudio_AudioGeometryGetTransform(geometry, out matrix4x4);
            }
            public static int AudioGeometryWriteMeshFile(IntPtr geometry, string filePath)
            {
                return ovrAudio_AudioGeometryWriteMeshFile(geometry, filePath);
            }
            public static int AudioGeometryReadMeshFile(IntPtr geometry, string filePath)
            {
                return ovrAudio_AudioGeometryReadMeshFile(geometry, filePath);
            }

        ///<summary>Converts a byte array to a hexadecimal string.</summary>
        /// <param name="bytes">A byte array</param>
        [Obsolete("Use ToHex(byte[])")]
        public static string BytesToHex(byte[] bytes)
        {
            return ToHex(bytes);
        }

        ///<summary>Converts a byte array to a hexadecimal string.</summary>
        /// <param name="bytes">A byte array</param>
        public static string ToHex(byte[] bytes)
        {
            var buf = new StringBuilder(bytes.Length * 2);
            for (int i = 0; i < bytes.Length; i++)
            {
                byte b = bytes[i];
                buf.Append(ToHexDigit((b >> 4) & 0x0F));
                buf.Append(ToHexDigit(b & 0x0F));
            }
            return buf.ToString();
        }

        private static char ToHexDigit(int n)
        {
            if (n < 0 || n > 15)
                throw new ArgumentException("Nibble value out of range: " + n);
            if (n <= 9)
                return (char)('0' + n);
            return (char)('A' + (n - 10));
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="writer"></param>
        /// <param name="geom"></param>
        private void WriteHeader(BinaryWriter writer, IGeometry geom)
        {
            //Byte Order
            WriteByteOrder(writer);

            //TODO: use "is" check, like in "WKTWriter.AppendGeometryTaggedText"?
            WKBGeometryTypes geometryType;
            switch (geom.GeometryType)
            {
                case "Point":
                    geometryType = WKBGeometryTypes.WKBPoint;
                    break;
                case "LineString":
                case "LinearRing":
                    geometryType = WKBGeometryTypes.WKBLineString;
                    break;
                case "Polygon":
                    geometryType = WKBGeometryTypes.WKBPolygon;
                    break;
                case "MultiPoint":
                    geometryType = WKBGeometryTypes.WKBMultiPoint;
                    break;
                case "MultiPolygon":
                    geometryType = WKBGeometryTypes.WKBMultiPolygon;
                    break;
                case "MultiLineString":
                    geometryType = WKBGeometryTypes.WKBMultiLineString;
                    break;
                case "GeometryCollection":
                    geometryType = WKBGeometryTypes.WKBGeometryCollection;
                    break;
                default:
                    Assert.ShouldNeverReachHere("Unknown geometry type:" + geom.GeometryType);
                    throw new ArgumentException("geom");
            }

            //Modify WKB Geometry type
            uint intGeometryType = (uint)geometryType & 0xff;
            if ((HandleOrdinates & Ordinates.Z) == Ordinates.Z)
            {
                intGeometryType += 1000;
                if (!Strict) intGeometryType |= 0x80000000;
            }

            if ((HandleOrdinates & Ordinates.M) == Ordinates.M)
            {
                intGeometryType += 2000;
                if (!Strict) intGeometryType |= 0x40000000;
            }

            //Flag for SRID if needed
            if (HandleSRID)
                intGeometryType |= 0x20000000;

            //
            writer.Write(intGeometryType);

            //Write SRID if needed
            if (HandleSRID)
                writer.Write(geom.SRID);
        }

        /// <summary>
        /// Writes a WKB representation of a given point.
        /// </summary>
        /// <param name="geometry"></param>
        /// <returns></returns>
        public virtual byte[] Write(IGeometry geometry)
        {
            byte[] bytes = GetBytes(geometry);
            Write(geometry, new MemoryStream(bytes));
            return bytes;
        }

        /// <summary>
        /// Writes a WKB representation of a given point.
        /// </summary>
        /// <param name="geometry"></param>
        /// <param name="stream"></param>
        /// <returns></returns>
        public virtual void Write(IGeometry geometry, Stream stream)
        {
            BinaryWriter writer = null;
            try
            {
                writer = EncodingType == ByteOrder.LittleEndian
                    ? new BinaryWriter(stream)
                    : new BEBinaryWriter(stream);
                Write(geometry, writer);
            }
            finally
            {
                if (writer != null)
                    ((IDisposable)writer).Dispose();
            }
        }


    static PropagationInterface FindInterface()
    {
        IntPtr temp;
        try
        {
            WwisePluginInterface.ovrAudio_GetPluginContext(out temp, ClientType.OVRA_CLIENT_TYPE_WWISE_UNKNOWN);
            Debug.Log("Propagation initialized with Wwise Oculus Spatializer plugin");
            return new WwisePluginInterface();
        }
        catch(System.DllNotFoundException)
        {
            // this is fine
        }
        try
        {
            FMODPluginInterface.ovrAudio_GetPluginContext(out temp, ClientType.OVRA_CLIENT_TYPE_FMOD);
            Debug.Log("Propagation initialized with FMOD Oculus Spatializer plugin");
            return new FMODPluginInterface();
        }
        catch (System.DllNotFoundException)
        {
            // this is fine
        }

        Debug.Log("Propagation initialized with Unity Oculus Spatializer plugin");
        return new UnityNativeInterface();
    }
        int SetPropagationThreadAffinity(UInt64 cpuMask);

        /***********************************************************************************/
        // Geometry API
        int CreateAudioGeometry(out IntPtr geometry);
        int DestroyAudioGeometry(IntPtr geometry);
        int AudioGeometryUploadMeshArrays(IntPtr geometry,
                                                        float[] vertices, int vertexCount,
                                                        int[] indices, int indexCount,
                                                        MeshGroup[] groups, int groupCount);
        int AudioGeometrySetTransform(IntPtr geometry, float[] matrix4x4);


        /// <summary>
        /// Returns the point representing the source or target point of this edge.
        /// This is only used if the edge has no source or target vertex.
        /// </summary>
        /// <param name="source">Boolean that specifies if the source or target point
        /// should be returned.</param>
        /// <returns>Returns the source or target point.</returns>
        public mxPoint GetTerminalPoint(bool source)
        {
            return (source) ? sourcePoint : targetPoint;
        }

        /// <summary>
        /// Sets the sourcePoint or targetPoint to the given point and returns the
        /// new point.
        /// </summary>
        /// <param name="point">Point to be used as the new source or target point.</param>
        /// <param name="source">Boolean that specifies if the source or target point
        /// should be set.</param>
        /// <returns>Returns the new point.</returns>
        public mxPoint SetTerminalPoint(mxPoint point, bool source)
        {
            if (source)
            {
                sourcePoint = point;
            }
            else
            {
                targetPoint = point;
            }

            return point;
        }

        /// <summary>
        /// Translates the geometry by the specified amount. That is, x and y of the
        /// geometry, the sourcePoint, targetPoint and all elements of points are
        /// translated by the given amount. X and y are only translated if the
        /// geometry is not relative. If TRANSLATE_CONTROL_POINTS is false, then
        /// are not modified by this function.
        /// </summary>
        /// <param name="dx">Integer that specifies the x-coordinate of the translation.</param>
        /// <param name="dy">Integer that specifies the y-coordinate of the translation.</param>
        public void Translate(double dx, double dy)
        {
            // Translates the geometry
            if (!Relative)
            {
                x += dx;
                y += dy;
            }

            // Translates the source point
            if (sourcePoint != null)
            {
                sourcePoint.X += dx;
                sourcePoint.Y += dy;
            }

            // Translates the target point
            if (targetPoint != null)
            {
                targetPoint.X += dx;
                targetPoint.Y += dy;
            }

            // Translate the control points
            if (TRANSLATE_CONTROL_POINTS &&
                points != null)
            {
                int count = points.Count;

                for (int i = 0; i < count; i++)
                {
                    mxPoint pt = points[i];

                    pt.X += dx;
                    pt.Y += dy;
                }
            }
        }

        /// <summary>
        /// Returns a new instance of the same geometry.
        /// </summary>
        /// <returns>Returns a clone of the geometry.</returns>
        public new mxGeometry Clone()
        {
            return new mxGeometry(this);
        }

        public static SqlGeometry ToSqlServerGeometry(SMGeometry smGeometry)
        {
            SqlGeometryBuilder builder = new SqlGeometryBuilder();
            SharpMapGeometryToSqlGeometry(builder, smGeometry);
            return builder.ConstructedGeometry;
        }

        private static void SharpMapGeometryToSqlGeometry(SqlGeometryBuilder geomBuilder, SMGeometry smGeometry)
        {
            
            switch (smGeometry.GeometryType)
            {
                case SMGeometryType.Point:
                    SharpMapPointToSqlGeometry(geomBuilder, smGeometry as SMPoint);
                    break;
                case SMGeometryType.LineString:
                    SharpMapLineStringToSqlGeometry(geomBuilder, smGeometry as SMLineString);
                    break;
                case SMGeometryType.Polygon:
                    SharpMapPolygonToSqlGeometry(geomBuilder, smGeometry as SMPolygon);
                    break;
                case SMGeometryType.MultiPoint:
                    SharpMapMultiPointToSqlGeometry(geomBuilder, smGeometry as SMMultiPoint);
                    break;
                case SMGeometryType.MultiLineString:
                    SharpMapMultiLineStringToSqlGeometry(geomBuilder, smGeometry as SMMultiLineString);
                    break;
                case SMGeometryType.MultiPolygon:
                    SharpMapMultiPolygonToSqlGeometry(geomBuilder, smGeometry as SMMultiPolygon);
                    break;
                case SMGeometryType.GeometryCollection:
                    SharpMapGeometryCollectionToSqlGeometry(geomBuilder, smGeometry as SMGeometryCollection);
                    break;
                default:
                    throw new ArgumentException(
                        String.Format("Cannot convert '{0}' geometry type", smGeometry.GeometryType), "smGeometry");
            }
        }

        private static void SharpMapGeometryCollectionToSqlGeometry(SqlGeometryBuilder geomBuilder, SMGeometryCollection geometryCollection)
        {
            geomBuilder.BeginGeometry(OpenGisGeometryType.GeometryCollection);
            for (int i = 0; i < geometryCollection.NumGeometries; i++ )
                SharpMapGeometryToSqlGeometry(geomBuilder, geometryCollection.Geometry(i));
            geomBuilder.EndGeometry();
        }

        private static void SharpMapMultiPolygonToSqlGeometry(SqlGeometryBuilder geomBuilder, SMMultiPolygon multiPolygon)
        {
            geomBuilder.BeginGeometry(OpenGisGeometryType.MultiPolygon);
            for (int i = 0; i < multiPolygon.NumGeometries; i++)
                SharpMapPolygonToSqlGeometry(geomBuilder, multiPolygon.Geometry(i) as SMPolygon);
            geomBuilder.EndGeometry();
        }

        private static void SharpMapMultiLineStringToSqlGeometry(SqlGeometryBuilder geomBuilder, SMMultiLineString multiLineString)
        {
            geomBuilder.BeginGeometry(OpenGisGeometryType.MultiLineString);
            for (int i = 0; i < multiLineString.NumGeometries; i++)
                SharpMapLineStringToSqlGeometry(geomBuilder, multiLineString.Geometry(i) as SMLineString);
            geomBuilder.EndGeometry();
        }

        private static void SharpMapMultiPointToSqlGeometry(SqlGeometryBuilder geomBuilder, SMMultiPoint multiPoint)
        {
            geomBuilder.BeginGeometry(OpenGisGeometryType.MultiPoint);
            for(int i = 0; i <= multiPoint.NumGeometries; i++)
                SharpMapPointToSqlGeometry(geomBuilder, multiPoint.Geometry(i));
            geomBuilder.EndGeometry();
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        private static double Avg(double a, double b)
        {
            return (a + b)/2.0;
        }

        /// <summary>
        /// Tests the interior vertices (if any)
        /// defined by an areal Geometry for the best inside point.
        /// If a component Geometry is not of dimension 2 it is not tested.
        /// </summary>
        /// <param name="geom">The point to add.</param>
        private void Add(IGeometry geom)
        {
            if (geom is Polygon)
                AddPolygon(geom);
            else if (geom is IGeometryCollection)
            {
                var gc = (IGeometryCollection) geom;
                foreach (var geometry in gc.Geometries)
                    Add(geometry);
            }
        }

        /// <summary>
        /// Finds an interior point of a Polygon.
        /// </summary>
        /// <param name="geometry">The geometry to analyze.</param>
        private void AddPolygon(IGeometry geometry)
        {
            if (geometry.IsEmpty)
                return;

            Coordinate intPt;
            double width;

            var bisector = HorizontalBisector(geometry);
            if (bisector.Length == 0.0)
            {
                width = 0;
                intPt = bisector.Coordinate;
            }
            else
            {
                var intersections = bisector.Intersection(geometry);
                var widestIntersection = WidestGeometry(intersections);
                width = widestIntersection.EnvelopeInternal.Width;
                intPt = Centre(widestIntersection.EnvelopeInternal);
            }
            if (_interiorPoint == null || width > _maxWidth)
            {
                _interiorPoint = intPt;
                _maxWidth = width;
            }
        }

        /// <returns>
        /// If point is a collection, the widest sub-point; otherwise,
        /// the point itself.
        /// </returns>
        private static IGeometry WidestGeometry(IGeometry geometry)
        {
            if (!(geometry is IGeometryCollection))
                return geometry;
            return WidestGeometry((IGeometryCollection) geometry);
        }

        private static IGeometry WidestGeometry(IGeometryCollection gc)
        {
            if (gc.IsEmpty)
                return gc;

            var widestGeometry = gc.GetGeometryN(0);
            // scan remaining geom components to see if any are wider
            for (int i = 1; i < gc.NumGeometries; i++) //Start at 1
                if (gc.GetGeometryN(i).EnvelopeInternal.Width > widestGeometry.EnvelopeInternal.Width)
                    widestGeometry = gc.GetGeometryN(i);
            return widestGeometry;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="geometry"></param>
        /// <returns></returns>
        protected ILineString HorizontalBisector(IGeometry geometry)
        {
            var envelope = geometry.EnvelopeInternal;

            /**
             * Original algorithm.  Fails when geometry contains a horizontal
             * segment at the Y midpoint.
             */
            // Assert: for areas, minx <> maxx
            //double avgY = Avg(envelope.MinY, envelope.MaxY);
            double bisectY = SafeBisectorFinder.GetBisectorY((IPolygon) geometry);

            return _factory.CreateLineString(
                new[] {new Coordinate(envelope.MinX, bisectY), new Coordinate(envelope.MaxX, bisectY)});
        }

SharpDX.Direct2D1.Geometry : IDisposable, ICallbackable, IUnknown

Fields :

public static Single DefaultFlatteningTolerance

Constructors :

public Geometry(IntPtr nativePtr = )

Methods :

public Single get_FlatteningTolerance()
public Void set_FlatteningTolerance(Single value = )
public Void Combine(Geometry inputGeometry = , CombineMode combineMode = , GeometrySink geometrySink = )
public Void Combine(Geometry inputGeometry = , CombineMode combineMode = , Single flatteningTolerance = , GeometrySink geometrySink = )
public GeometryRelation Compare(Geometry inputGeometry = )
public GeometryRelation Compare(Geometry inputGeometry = , Single flatteningTolerance = )
public Single ComputeArea()
public Single ComputeArea(Single flatteningTolerance = )
public Single ComputeLength()
public Single ComputeLength(Single flatteningTolerance = )
public RawVector2 ComputePointAtLength(Single length = , RawVector2& unitTangentVector = )
public RawVector2 ComputePointAtLength(Single length = , Single flatteningTolerance = , RawVector2& unitTangentVector = )
public Boolean FillContainsPoint(RawPoint point = )
public Boolean FillContainsPoint(RawVector2 point = )
public Boolean FillContainsPoint(RawPoint point = , Single flatteningTolerance = )
public Boolean FillContainsPoint(RawVector2 point = , Single flatteningTolerance = )
public Boolean FillContainsPoint(RawPoint point = , RawMatrix3x2 worldTransform = , Single flatteningTolerance = )
public RawRectangleF GetBounds()
public RawRectangleF GetWidenedBounds(Single strokeWidth = )
public RawRectangleF GetWidenedBounds(Single strokeWidth = , Single flatteningTolerance = )
public RawRectangleF GetWidenedBounds(Single strokeWidth = , StrokeStyle strokeStyle = , Single flatteningTolerance = )
public Void Outline(GeometrySink geometrySink = )
public Void Outline(Single flatteningTolerance = , GeometrySink geometrySink = )
public Void Simplify(GeometrySimplificationOption simplificationOption = , SimplifiedGeometrySink geometrySink = )
public Void Simplify(GeometrySimplificationOption simplificationOption = , Single flatteningTolerance = , SimplifiedGeometrySink geometrySink = )
public Boolean StrokeContainsPoint(RawPoint point = , Single strokeWidth = )
public Boolean StrokeContainsPoint(RawVector2 point = , Single strokeWidth = )
public Boolean StrokeContainsPoint(RawPoint point = , Single strokeWidth = , StrokeStyle strokeStyle = )
public Boolean StrokeContainsPoint(RawVector2 point = , Single strokeWidth = , StrokeStyle strokeStyle = )
public Boolean StrokeContainsPoint(RawPoint point = , Single strokeWidth = , StrokeStyle strokeStyle = , RawMatrix3x2 transform = )
public Boolean StrokeContainsPoint(RawVector2 point = , Single strokeWidth = , StrokeStyle strokeStyle = , RawMatrix3x2 transform = )
public Boolean StrokeContainsPoint(RawPoint point = , Single strokeWidth = , StrokeStyle strokeStyle = , RawMatrix3x2 transform = , Single flatteningTolerance = )
public Void Tessellate(TessellationSink tessellationSink = )
public Void Tessellate(Single flatteningTolerance = , TessellationSink tessellationSink = )
public Void Widen(Single strokeWidth = , GeometrySink geometrySink = )
public Void Widen(Single strokeWidth = , Single flatteningTolerance = , GeometrySink geometrySink = )
public Void Widen(Single strokeWidth = , StrokeStyle strokeStyle = , Single flatteningTolerance = , GeometrySink geometrySink = )
public static Geometry op_Explicit(IntPtr nativePtr = )
public RawRectangleF GetBounds(Nullable<RawMatrix3x2> worldTransform = )
public RawRectangleF GetWidenedBounds(Single strokeWidth = , StrokeStyle strokeStyle = , Nullable<RawMatrix3x2> worldTransform = , Single flatteningTolerance = )
public RawBool StrokeContainsPoint(RawVector2 point = , Single strokeWidth = , StrokeStyle strokeStyle = , Nullable<RawMatrix3x2> worldTransform = , Single flatteningTolerance = )
public RawBool FillContainsPoint(RawVector2 point = , Nullable<RawMatrix3x2> worldTransform = , Single flatteningTolerance = )
public GeometryRelation Compare(Geometry inputGeometry = , Nullable<RawMatrix3x2> inputGeometryTransform = , Single flatteningTolerance = )
public Void Simplify(GeometrySimplificationOption simplificationOption = , Nullable<RawMatrix3x2> worldTransform = , Single flatteningTolerance = , SimplifiedGeometrySink geometrySink = )
public Void Tessellate(Nullable<RawMatrix3x2> worldTransform = , Single flatteningTolerance = , TessellationSink tessellationSink = )
public Void Combine(Geometry inputGeometry = , CombineMode combineMode = , Nullable<RawMatrix3x2> inputGeometryTransform = , Single flatteningTolerance = , SimplifiedGeometrySink geometrySink = )
public Void Outline(Nullable<RawMatrix3x2> worldTransform = , Single flatteningTolerance = , SimplifiedGeometrySink geometrySink = )
public Single ComputeArea(Nullable<RawMatrix3x2> worldTransform = , Single flatteningTolerance = )
public Single ComputeLength(Nullable<RawMatrix3x2> worldTransform = , Single flatteningTolerance = )
public RawVector2 ComputePointAtLength(Single length = , Nullable<RawMatrix3x2> worldTransform = , Single flatteningTolerance = , RawVector2& unitTangentVector = )
public Void Widen(Single strokeWidth = , StrokeStyle strokeStyle = , Nullable<RawMatrix3x2> worldTransform = , Single flatteningTolerance = , SimplifiedGeometrySink geometrySink = )
public Factory get_Factory()
public Void QueryInterface(Guid guid = , IntPtr& outPtr = )
public IntPtr QueryInterfaceOrNull(Guid guid = )
public T QueryInterface()
public T QueryInterfaceOrNull()
public Object get_Tag()
public Void set_Tag(Object value = )
public IntPtr get_NativePointer()
public Void set_NativePointer(IntPtr value = )
public Void add_Disposing(EventHandler<EventArgs> value = )
public Void remove_Disposing(EventHandler<EventArgs> value = )
public Void add_Disposed(EventHandler<EventArgs> value = )
public Void remove_Disposed(EventHandler<EventArgs> value = )
public Boolean get_IsDisposed()
public Void Dispose()
public Type GetType()
public String ToString()
public Boolean Equals(Object obj = )
public Int32 GetHashCode()