Example #1
0
        /// <summary>
        /// 使用斜率截距快速算法
        /// 以全球国家为例:220毫秒
        /// </summary>
        /// <param name="ply"></param>
        private unsafe void PolygonToPath(ShapePolygon ply)
        {
            float kLon      = _quickTransformArgs.kLon;
            float kLat      = _quickTransformArgs.kLat;
            float bLon      = _quickTransformArgs.bLon;
            float bLat      = _quickTransformArgs.bLat;
            int   ringCount = ply.Rings.Length;

            for (int ri = 0; ri < ringCount; ri++)
            {
                ShapePoint[] prjPts = ply.Rings[ri].Points;
                int          nCount = prjPts.Length;
                PointF[]     pts    = new PointF[nCount];
                fixed(PointF *ptr0 = pts)
                {
                    PointF *ptr = ptr0;

                    for (int i = 0; i < nCount; i++, ptr++)
                    {
                        ptr->X = (float)(kLon * prjPts[i].X + bLon);
                        ptr->Y = (float)(kLat * prjPts[i].Y + bLat);
                    }
                }

                _path.AddPolygon(pts);
            }
        }
        public unsafe void ToBitmap(PointF[] points, byte[] types, Color trueColor, Color emptyColor, Envelope dstEnvelope, Size size, ref Bitmap buffer)
        {
            if (points == null || points.Length == 0 || types == null || types.Length == 0 || dstEnvelope == null || size.IsEmpty)
            {
                return;
            }
            ShapePoint leftUpCoord = dstEnvelope.LeftUpPoint;
            float      resolutionX = (float)dstEnvelope.Width / (float)size.Width;
            float      resolutionY = (float)dstEnvelope.Height / (float)size.Height;
            float      leftUpX     = (float)leftUpCoord.X;
            float      leftUpY     = (float)leftUpCoord.Y;

            fixed(PointF *ptrf = points)
            {
                PointF *ptr = ptrf;

                for (int i = 0; i < points.Length; i++)
                {
                    ptr->X = ((float)ptr->X - leftUpX) / resolutionX;
                    ptr->Y = -((float)ptr->Y - leftUpY) / resolutionY;
                    ptr++;
                }
            }

            using (Graphics g = Graphics.FromImage(buffer))
            {
                using (GraphicsPath pth = new GraphicsPath(points, types))
                {
                    using (SolidBrush brush = new SolidBrush(trueColor))
                    {
                        g.FillPath(brush, pth);
                    }
                }
            }
        }
Example #3
0
        /// <summary>
        /// 将基于AOI计算出的等值线还原到全图
        /// </summary>
        /// <param name="contourLines"></param>
        /// <param name="aoi"></param>
        private unsafe void OffsetToFull(List <ContourLine> contourLines, int offsetRow, int offsetCol)
        {
            if (contourLines == null || contourLines.Count == 0)
            {
                return;
            }
            int ptCount = 0;

            foreach (ContourLine cl in contourLines)
            {
                if (cl == null || cl.Count == 0)
                {
                    continue;
                }
                ptCount = cl.Count;
                fixed(PointF *ptr0 = cl.Points)
                {
                    PointF *ptr = ptr0;

                    for (int i = 0; i < ptCount; i++, ptr++)
                    {
                        ptr->X = ptr->X + offsetCol;
                        ptr->Y = ptr->Y + offsetRow;
                    }
                }
            }
        }
Example #4
0
        /// <summary>
        /// Counts the number of counter-clockwise windings that the polygon makes around a given <paramref name="testPoint">point</paramref>.
        /// </summary>
        /// <param name="testPoint">The test point.</param>
        /// <param name="vertices">A pointer to the array of vertices defining the polygon.</param>
        /// <param name="vertexCount">The number of vertices in the array.</param>
        /// <returns>The number of CCW windings.</returns>
        /// <remarks>
        /// Algorithm as given on <a href="http://softsurfer.com/Archive/algorithm_0103/algorithm_0103.htm">http://softsurfer.com/Archive/algorithm_0103/algorithm_0103.htm</a>.
        /// </remarks>
        private static unsafe int CountWindings(PointF testPoint, PointF *vertices, int vertexCount)
        {
            int wn = 0;             // the winding number counter

            // loop through all edges of the polygon
            int point0 = vertexCount - 1;

            for (int point1 = 0; point1 < vertexCount; point0 = point1, point1++)
            {
                // edge from point0 to point1
                if (vertices[point0].Y <= testPoint.Y)
                {
                    // start y <= testPoint.y
                    if (vertices[point1].Y > testPoint.Y)                              // an upward crossing
                    {
                        if (IsLeft(vertices[point0], vertices[point1], testPoint) > 0) // testPoint left of edge
                        {
                            wn++;                                                      // have a valid up intersect
                        }
                    }
                }
                else
                {
                    // start y > testPoint.y (no test needed)
                    if (vertices[point1].Y <= testPoint.Y)                             // a downward crossing
                    {
                        if (IsLeft(vertices[point0], vertices[point1], testPoint) < 0) // testPoint right of edge
                        {
                            --wn;                                                      // have a valid down intersect
                        }
                    }
                }
            }
            return(wn);
        }
Example #5
0
        private static unsafe bool CheckIsComplex(PointF *vertices, int vertexCount)
        {
            // the line segments immediately preceding and succeeding a given segment are never considered as "intersecting"
            for (int n = 2; n < vertexCount - 1; n++)
            {
                for (int i = 0; i <= n - 2; i++)
                {
                    PointF intersection;
                    if (Vector.IntersectLineSegments(vertices[n], vertices[n + 1], vertices[i], vertices[i + 1], out intersection))
                    {
                        return(true);
                    }
                }
            }

            // when checking against the last line segment, skip the first line segment (since they are adjacent)
            for (int i = 1; i < vertexCount - 2; i++)
            {
                PointF intersection;
                if (Vector.IntersectLineSegments(vertices[vertexCount - 1], vertices[0], vertices[i], vertices[i + 1], out intersection))
                {
                    return(true);
                }
            }
            return(false);
        }
Example #6
0
        private unsafe void DrawVLabel1Scales(Graphics g, float beginY, float endY, int lineHeight, float span, float resY)
        {
            Matrix   oldMatrix = g.Transform;
            float    v         = 0;
            PointF   pt        = new PointF(3 * FONT_MARGIN, 0);
            GCHandle handle    = GCHandle.Alloc(pt, GCHandleType.Pinned);
            PointF * ptr       = (PointF *)handle.AddrOfPinnedObject();

            try
            {
                do
                {
                    ptr->Y = beginY + 1;
                    _matrix.Reset();
                    _matrix.RotateAt(90, *ptr);
                    g.Transform = _matrix;
                    g.DrawString(((int)v).ToString(), _font, _labelBrush, *ptr);
                    v      += resY;
                    beginY += span;
                }while (beginY < endY);
            }
            finally
            {
                g.Transform = oldMatrix;
                handle.Free();
            }
        }
Example #7
0
        unsafe void PointToGlobalSpace(PointF p, PointF *outPoint)
        {
            float px = LocalFlipX ? (1 - p.X) : p.X;
            float py = LocalFlipY ? (1 - p.Y) : p.Y;

            outPoint->X = ClientRectangle.X + px * ClientRectangle.Width;
            outPoint->Y = ClientRectangle.Y + py * ClientRectangle.Height;
        }
Example #8
0
        private unsafe void DrawContour(IDrawArgs drawArgs, ContourLine cntLine, ContourClass cntClass, ICanvas canvas)
        {
            if (!cntClass.IsDisplay)
            {
                return;
            }
            ICoordinateTransform tran = canvas.CoordTransform;
            int nCount = cntLine.Count;

            PointF[] pts       = new PointF[nCount];
            GCHandle dstHandle = GCHandle.Alloc(pts, GCHandleType.Pinned);
            GCHandle srcHandle = GCHandle.Alloc(cntLine.Points, GCHandleType.Pinned);

            try
            {
                MemoryCopy(dstHandle.AddrOfPinnedObject(), srcHandle.AddrOfPinnedObject(), nCount << _pointfSize); // nCount * sizeof(PointF)
                QuickTransform quickTran = drawArgs.QuickTransformArgs;
                fixed(PointF *ptr0 = pts)
                {
                    PointF *ptr = ptr0;

                    for (int i = 0; i < nCount; i++, ptr++)
                    {
                        quickTran.Transform(ptr);
                    }
                }
                Graphics g = drawArgs.Graphics as Graphics;
                //
                if (_isUseCurveRender)
                {
                    g.DrawCurve(cntClass.Pen, pts, _tension);
                }
                else
                {
                    _grahpicPath.Reset();
                    _grahpicPath.AddLines(pts);
                    g.DrawPath(cntClass.Pen, _grahpicPath);
                }
                //
                if (_isLabel)
                {
                    if (_isCheckConflicting)
                    {
                        if (_conflictor.IsConflicted(pts[0], cntClass.LabelBuffer.Size))
                        {
                            return;
                        }
                        _conflictor.HoldPosition(pts[0], cntClass.LabelBuffer.Size);
                    }
                    g.DrawImageUnscaled(cntClass.LabelBuffer, (int)pts[0].X, (int)pts[0].Y);
                }
            }
            finally
            {
                dstHandle.Free();
                srcHandle.Free();
            }
        }
Example #9
0
            unsafe HRESULT IOleControlSite.TransformCoords(Point *pPtlHimetric, PointF *pPtfContainer, XFORMCOORDS dwFlags)
            {
                if (pPtlHimetric is null || pPtfContainer is null)
                {
                    return(HRESULT.E_INVALIDARG);
                }

                HRESULT hr = SetupLogPixels(false);

                if (hr < 0)
                {
                    return(hr);
                }

                if ((dwFlags & XFORMCOORDS.HIMETRICTOCONTAINER) != 0)
                {
                    if ((dwFlags & XFORMCOORDS.SIZE) != 0)
                    {
                        pPtfContainer->X = (float)host.HM2Pix(pPtlHimetric->X, logPixelsX);
                        pPtfContainer->Y = (float)host.HM2Pix(pPtlHimetric->Y, logPixelsY);
                    }
                    else if ((dwFlags & XFORMCOORDS.POSITION) != 0)
                    {
                        pPtfContainer->X = (float)host.HM2Pix(pPtlHimetric->X, logPixelsX);
                        pPtfContainer->Y = (float)host.HM2Pix(pPtlHimetric->Y, logPixelsY);
                    }
                    else
                    {
                        Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\t dwFlags not supported: " + dwFlags);
                        return(HRESULT.E_INVALIDARG);
                    }
                }
                else if ((dwFlags & XFORMCOORDS.CONTAINERTOHIMETRIC) != 0)
                {
                    if ((dwFlags & XFORMCOORDS.SIZE) != 0)
                    {
                        pPtlHimetric->X = host.Pix2HM((int)pPtfContainer->X, logPixelsX);
                        pPtlHimetric->Y = host.Pix2HM((int)pPtfContainer->Y, logPixelsY);
                    }
                    else if ((dwFlags & XFORMCOORDS.POSITION) != 0)
                    {
                        pPtlHimetric->X = host.Pix2HM((int)pPtfContainer->X, logPixelsX);
                        pPtlHimetric->Y = host.Pix2HM((int)pPtfContainer->Y, logPixelsY);
                    }
                    else
                    {
                        Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\t dwFlags not supported: " + dwFlags);
                        return(HRESULT.E_INVALIDARG);
                    }
                }
                else
                {
                    Debug.WriteLineIf(AxHTraceSwitch.TraceVerbose, "\t dwFlags not supported: " + dwFlags);
                    return(HRESULT.E_INVALIDARG);
                }

                return(HRESULT.S_OK);
            }
Example #10
0
            internal static partial int GdipWarpPath(
#if NET7_0_OR_GREATER
                [MarshalUsing(typeof(HandleRefMarshaller))]
#endif
                HandleRef path,
#if NET7_0_OR_GREATER
                [MarshalUsing(typeof(HandleRefMarshaller))]
#endif
                HandleRef matrix, PointF *points, int count, float srcX, float srcY, float srcWidth, float srcHeight, WarpMode warpMode, float flatness);
Example #11
0
            internal static partial int GdipDrawBeziers(
#if NET7_0_OR_GREATER
                [MarshalUsing(typeof(HandleRefMarshaller))]
#endif
                HandleRef graphics,
#if NET7_0_OR_GREATER
                [MarshalUsing(typeof(HandleRefMarshaller))]
#endif
                HandleRef pen, PointF *points, int count);
        public unsafe void ToBitmap(Dictionary <ShapePolygon, Color> vectors, Color emptyColor, Envelope dstEnvelope, Size size, ref Bitmap buffer)
        {
            if (vectors == null || vectors.Count == 0 || dstEnvelope == null || size.Width == 0 || size.Height == 0 || buffer == null)
            {
                return;
            }
            ShapePoint leftUpCoord = dstEnvelope.LeftUpPoint;
            float      resolutionX = (float)dstEnvelope.Width / (float)size.Width;
            float      resolutionY = (float)dstEnvelope.Height / (float)size.Height;
            float      leftUpX     = (float)leftUpCoord.X;
            float      leftUpY     = (float)leftUpCoord.Y;

            using (Graphics g = Graphics.FromImage(buffer))
            {
                //g.Clear(emptyColor);
                g.InterpolationMode = InterpolationMode.NearestNeighbor;
                //g.SmoothingMode = SmoothingMode.HighQuality;
                foreach (ShapePolygon ply in vectors.Keys)
                {
                    if (!dstEnvelope.IsInteractived(ply.Envelope))
                    {
                        continue;
                    }
                    using (GraphicsPath pth = new GraphicsPath())
                    {
                        ShapeRing[] rings = ply.Rings;
                        foreach (ShapeRing ring in rings)
                        {
                            if (!dstEnvelope.IsInteractived(ring.Envelope))
                            {
                                continue;
                            }
                            PointF[] pts = new PointF[ring.Points.Length];
                            fixed(PointF *ptrf = pts)
                            {
                                PointF *ptr = ptrf;

                                ShapePoint[] shpts = ring.Points;
                                foreach (ShapePoint pt in shpts)
                                {
                                    ptr->X = ((float)pt.X - leftUpX) / resolutionX;
                                    ptr->Y = -((float)pt.Y - leftUpY) / resolutionY;
                                    ptr++;
                                }
                            }

                            pth.AddPolygon(pts);
                        }
                        using (SolidBrush brush = new SolidBrush(vectors[ply]))
                        {
                            g.FillPath(brush, pth);
                        }
                    }
                }
            }
        }
Example #13
0
        public unsafe void Render(object sender, IDrawArgs drawArgs)
        {
            if (_canvas == null)
            {
                _canvas         = sender as ICanvas;
                _spatialRef     = GetSpatialRef();
                _coordTransfrom = _canvas.CoordTransform;
            }
            Graphics g = drawArgs.Graphics as Graphics;

            if (_gridLines == null)
            {
                bool isOK = ComputeValidGeoRange();
                if (!isOK)
                {
                    return;
                }
                ComputeGridLines(_coordTransfrom);
            }
            if (_gridLines != null)
            {
                GCHandle prjHandle    = GCHandle.Alloc(_allPrjPoints, GCHandleType.Pinned);
                GCHandle screenHandle = GCHandle.Alloc(_allPixelPoints, GCHandleType.Pinned);
                try
                {
                    QuickTransform qickTran = _coordTransfrom.QuickTransform;
                    int            ptCount  = _allPixelPoints.Length;
                    MemoryCopy(screenHandle.AddrOfPinnedObject(), prjHandle.AddrOfPinnedObject(), ptCount * Marshal.SizeOf(typeof(PointF)));
                    fixed(PointF *ptr0 = _allPixelPoints)
                    {
                        PointF *pixPtr = ptr0;

                        for (int i = 0; i < ptCount; i++, pixPtr++)
                        {
                            qickTran.Transform(pixPtr);
                        }
                    }
                    //draw lon lines
                    DrawLines(g, 0, _lonLines);
                    //draw lat lines
                    int end = Math.Min(_lonLines + _latLines, _gridLines.Count);
                    DrawLines(g, _lonLines, end);
                    //label
                    DrawLabel(g, qickTran);
                }
                finally
                {
                    prjHandle.Free();
                    screenHandle.Free();
                }
            }
        }
Example #14
0
            internal static partial int GdipEnumerateMetafileSrcRectDestPoints(
#if NET7_0_OR_GREATER
                [MarshalUsing(typeof(HandleRefMarshaller))]
#endif
                HandleRef graphics,
#if NET7_0_OR_GREATER
                [MarshalUsing(typeof(HandleRefMarshaller))]
#endif
                HandleRef metafile, PointF *destPoints, int count, ref RectangleF srcRect, GraphicsUnit pageUnit, Graphics.EnumerateMetafileProc callback, IntPtr callbackdata,
#if NET7_0_OR_GREATER
                [MarshalUsing(typeof(HandleRefMarshaller))]
#endif
                HandleRef imageattributes);
Example #15
0
        /// <summary>
        /// Green's Theorem-derived formula to compute the area of the polygon.
        /// </summary>
        private static unsafe double ComputeSimpleArea(PointF *vertices, int vertexCount)
        {
            // technically, this formula does work for complex polygons, it's just that we define inside/outside a complex polygon differently.
            double result = 0;
            int    point0 = vertexCount - 1;

            for (int point1 = 0; point1 < vertexCount; point0 = point1, point1++)
            {
                // ensure each multiplication is carried out to double precision
                result += (double)vertices[point0].X * vertices[point1].Y - (double)vertices[point1].X * vertices[point0].Y;
            }
            return(Math.Abs(result / 2));
        }
Example #16
0
        unsafe void DrawPolyline(PaintEventArgs e, PointF *points, int pointsCount, bool closed)
        {
            if (pointsCount > 1)
            {
                for (int i = 1; i < pointsCount; ++i)
                {
                    DrawLine(e, points[i - 1], points[i]);
                }

                if (closed && pointsCount > 2)
                {
                    DrawLine(e, points[pointsCount - 1], points[0]);
                }
            }
        }
Example #17
0
        unsafe HRESULT Ole32.IOleControlSite.TransformCoords(Point *pPtlHimetric, PointF *pPtfContainer, Ole32.XFORMCOORDS dwFlags)
        {
            if (pPtlHimetric == null || pPtfContainer == null)
            {
                return(HRESULT.E_INVALIDARG);
            }

            if ((dwFlags & Ole32.XFORMCOORDS.HIMETRICTOCONTAINER) != 0)
            {
                if ((dwFlags & Ole32.XFORMCOORDS.SIZE) != 0)
                {
                    pPtfContainer->X = (float)WebBrowserHelper.HM2Pix(pPtlHimetric->X, WebBrowserHelper.LogPixelsX);
                    pPtfContainer->Y = (float)WebBrowserHelper.HM2Pix(pPtlHimetric->Y, WebBrowserHelper.LogPixelsY);
                }
                else if ((dwFlags & Ole32.XFORMCOORDS.POSITION) != 0)
                {
                    pPtfContainer->X = (float)WebBrowserHelper.HM2Pix(pPtlHimetric->X, WebBrowserHelper.LogPixelsX);
                    pPtfContainer->Y = (float)WebBrowserHelper.HM2Pix(pPtlHimetric->Y, WebBrowserHelper.LogPixelsY);
                }
                else
                {
                    return(HRESULT.E_INVALIDARG);
                }
            }
            else if ((dwFlags & Ole32.XFORMCOORDS.CONTAINERTOHIMETRIC) != 0)
            {
                if ((dwFlags & Ole32.XFORMCOORDS.SIZE) != 0)
                {
                    pPtlHimetric->X = WebBrowserHelper.Pix2HM((int)pPtfContainer->X, WebBrowserHelper.LogPixelsX);
                    pPtlHimetric->Y = WebBrowserHelper.Pix2HM((int)pPtfContainer->Y, WebBrowserHelper.LogPixelsY);
                }
                else if ((dwFlags & Ole32.XFORMCOORDS.POSITION) != 0)
                {
                    pPtlHimetric->X = WebBrowserHelper.Pix2HM((int)pPtfContainer->X, WebBrowserHelper.LogPixelsX);
                    pPtlHimetric->Y = WebBrowserHelper.Pix2HM((int)pPtfContainer->Y, WebBrowserHelper.LogPixelsY);
                }
                else
                {
                    return(HRESULT.E_INVALIDARG);
                }
            }
            else
            {
                return(HRESULT.E_INVALIDARG);
            }

            return(HRESULT.S_OK);
        }
Example #18
0
        unsafe void InitalizeFirstSquare(PointF *points)
        {
            var globalSide = (float)Math.Min(Width, Height);
            var localSideX = globalSide / Width;
            var localSideY = globalSide / Height;

            float x1 = (1.0f - localSideX) / 2;
            float x2 = x1 + localSideX;
            float y1 = (1.0f - localSideY) / 2;
            float y2 = y1 + localSideY;

            points[0] = new PointF(x1, y1);
            points[1] = new PointF(x2, y1);
            points[2] = new PointF(x2, y2);
            points[3] = new PointF(x1, y2);
        }
Example #19
0
        public unsafe PointF[] GeoCoord2PixelCoord(ShapePoint[] points)
        {
            PointF[] ptfs = new PointF[points.Length];
            fixed(PointF *ptr = ptfs)
            {
                PointF *pt = ptr;

                for (int i = 0; i < ptfs.Length; i++, pt++)
                {
                    pt->X = (float)points[i].X;
                    pt->Y = (float)points[i].Y;
                }
            }

            GeoCoord2PixelCoord(ptfs);
            return(ptfs);
        }
Example #20
0
        private unsafe void DrawLines(Graphics g, int beginLine, int endLine)
        {
            try
            {
                fixed(PointF *ptr0 = _allPixelPoints)
                {
                    PointF *allPointPtr = ptr0;
                    //
                    int ptCount = 0;

                    allPointPtr = ptr0;
                    PointF[] vertexBuffer  = null;
                    int      prePointCount = 0;

                    //for (int iLine = beginLine; iLine < endLine - 1; iLine++)
                    for (int iLine = beginLine; iLine < endLine; iLine++)
                    {
                        ptCount = _gridLines[iLine].SegmentCount;
                        if (prePointCount != ptCount)
                        {
                            vertexBuffer  = new PointF[ptCount];
                            prePointCount = ptCount;
                        }
                        fixed(PointF *buffer0 = vertexBuffer)
                        {
                            PointF *buffer = buffer0;

                            allPointPtr = ptr0 + _gridLines[iLine].BeginIndex;
                            for (int iPt = 0; iPt < ptCount; iPt++, buffer++, allPointPtr++)
                            {
                                buffer->X = allPointPtr->X;
                                buffer->Y = allPointPtr->Y;
                            }
                        }
                        //
                        g.DrawCurve(_gridPen, vertexBuffer);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
Example #21
0
        private static unsafe double ComputeComplexArea(RectangleF bounds, PointF *vertices, int vertexCount)
        {
            // This algorithm is more computationally expensive and provides a weaker approximation of
            // the area of an n-polygon when compared with Formula.AreaOfPolygon, although it does
            // compute the desired area of a self-intersecting polygon.
            int areaInPixels = 0;

            for (float r = bounds.Left; r <= bounds.Right; r++)
            {
                for (float c = bounds.Top; c <= bounds.Bottom; c++)
                {
                    if (CountWindings(new PointF(r, c), vertices, vertexCount) != 0)
                    {
                        areaInPixels++;
                    }
                }
            }
            return(areaInPixels);
        }
Example #22
0
        private unsafe void method_0(Matrix4D transform)
        {
            int length = this.vector4D_0.Length;

            if (this.pointF_0 == null || this.pointF_0.Length != length)
                this.pointF_0 = new PointF[length];
            fixed(Vector4D *vector4DPtr1 = this.vector4D_0)
            fixed(PointF * pointFPtr1 = this.pointF_0)
            {
                Vector4D *vector4DPtr2 = vector4DPtr1;
                PointF *  pointFPtr2   = pointFPtr1;

                for (int index = 0; index < length; ++index)
                {
                    *pointFPtr2 = transform.TransformToPointF(*vector4DPtr2);
                    ++vector4DPtr2;
                    ++pointFPtr2;
                }
            }
        }
Example #23
0
        private unsafe void Project(ContourLine cntLine, ICanvas canvas)
        {
            ICoordinateTransform tran = canvas.CoordTransform;

            if (tran == null)
            {
                return;
            }
            int nCount = cntLine.Count;

            fixed(PointF *ptr0 = cntLine.Points)
            {
                PointF *ptr = ptr0;

                for (int i = 0; i < nCount; i++, ptr++)
                {
                    tran.Raster2Prj(ptr);
                }
            }

            cntLine.UpdateEnvelope();
        }
Example #24
0
        private unsafe Feature GetFeature(ContourLine cntLine, ICanvas canvas, int OID)
        {
            int ptCount = cntLine.Count;

            ShapePoint[] pts = new ShapePoint[ptCount];
            fixed(PointF *ptr0 = cntLine.Points)
            {
                PointF *ptr = ptr0;

                for (int i = 0; i < ptCount; i++, ptr++)
                {
                    double geoX, geoY;
                    canvas.CoordTransform.Prj2Geo(ptr->X, ptr->Y, out geoX, out geoY);
                    pts[i] = new ShapePoint(geoX, geoY);
                }
            }

            ShapeLineString ring = new ShapeLineString(pts);
            ShapePolyline   ply  = new ShapePolyline(new ShapeLineString[] { ring });
            Feature         fet  = new Feature(OID, ply, new string[] { "Contour" }, new string[] { cntLine.ContourValue.ToString() }, null);

            return(fet);
        }
Example #25
0
        private unsafe ContourLine ReadCntLine(BinaryReader br, double contourValue)
        {
            ContourLine.ContourEnvelope evp = ReadEnvelope(br);
            ContourLine cntLine             = new ContourLine(contourValue);

            cntLine.ClassIndex = br.ReadInt32();
            int ptCount = br.ReadInt32();

            PointF[] pts = new PointF[ptCount];
            fixed(PointF *ptr0 = pts)
            {
                PointF *ptr = ptr0;

                for (int i = 0; i < ptCount; i++, ptr++)
                {
                    ptr->X = br.ReadSingle();
                    ptr->Y = br.ReadSingle();
                }
            }

            cntLine.AddPoints(pts);
            return(cntLine);
        }
Example #26
0
        public void UpdateEnvelope()
        {
            float minX = float.MaxValue;
            float minY = float.MaxValue;
            float maxX = float.MinValue;
            float maxY = float.MinValue;

            unsafe
            {
                fixed(PointF *ptr0 = this.Points)
                {
                    PointF *ptr = ptr0;

                    for (int i = 0; i < this.Count; i++, ptr++)
                    {
                        if (ptr->X < minX)
                        {
                            minX = ptr->X;
                        }
                        if (ptr->X > maxX)
                        {
                            maxX = ptr->X;
                        }
                        if (ptr->Y < minY)
                        {
                            minY = ptr->Y;
                        }
                        if (ptr->Y > maxY)
                        {
                            maxY = ptr->Y;
                        }
                    }
                }
            }
            _envelope = new ContourEnvelope(minX, maxX, minY, maxY);
        }
Example #27
0
        private unsafe Feature GetFeature(ContourLine cntLine, double resX, double resY,
                                          double minX, double maxY, int OID)
        {
            int ptCount = cntLine.Count;

            ShapePoint[] pts = new ShapePoint[ptCount];
            fixed(PointF *ptr0 = cntLine.Points)
            {
                PointF *ptr = ptr0;

                for (int i = 0; i < ptCount; i++, ptr++)
                {
                    ptr->X = (float)(ptr->X * resX + minX);
                    ptr->Y = (float)(maxY - ptr->Y * resY);
                    pts[i] = new ShapePoint(ptr->X, ptr->Y);
                }
            }

            ShapeLineString ring = new ShapeLineString(pts);
            ShapePolyline   ply  = new ShapePolyline(new ShapeLineString[] { ring });
            Feature         fet  = new Feature(OID, ply, new string[] { "Contour" }, new string[] { cntLine.ContourValue.ToString() }, null);

            return(fet);
        }
Example #28
0
        public override void Render(Surface src, Surface dst, Rectangle[] rois, int startIndex, int length)
        {
            ColorBgra colTransparent = ColorBgra.Transparent;

            unsafe
            {
                int     aaSampleCount = quality * quality;
                PointF *aaPoints      = stackalloc PointF[aaSampleCount];
                PixelUtils.GetRgssOffsets(aaPoints, aaSampleCount, quality);
                ColorBgra *samples = stackalloc ColorBgra[aaSampleCount];

                TransformData td;

                for (int n = startIndex; n < startIndex + length; ++n)
                {
                    Rectangle rect = rois[n];

                    for (int y = rect.Top; y < rect.Bottom; y++)
                    {
                        ColorBgra *dstPtr = dst.GetPointAddressUnchecked(rect.Left, y);

                        double relativeY = y - this.yCenterOffset;

                        for (int x = rect.Left; x < rect.Right; x++)
                        {
                            double relativeX = x - this.xCenterOffset;

                            int sampleCount = 0;

                            for (int p = 0; p < aaSampleCount; ++p)
                            {
                                td.X = relativeX + aaPoints[p].X;
                                td.Y = relativeY - aaPoints[p].Y;

                                InverseTransform(ref td);

                                float sampleX = (float)(td.X + this.xCenterOffset);
                                float sampleY = (float)(td.Y + this.yCenterOffset);

                                ColorBgra sample = colPrimary;

                                if (IsOnSurface(src, sampleX, sampleY))
                                {
                                    sample = src.GetBilinearSample(sampleX, sampleY);
                                }
                                else
                                {
                                    switch (this.edgeBehavior)
                                    {
                                    case WarpEdgeBehavior.Clamp:
                                        sample = src.GetBilinearSampleClamped(sampleX, sampleY);
                                        break;

                                    case WarpEdgeBehavior.Wrap:
                                        sample = src.GetBilinearSampleWrapped(sampleX, sampleY);
                                        break;

                                    case WarpEdgeBehavior.Reflect:
                                        sample = src.GetBilinearSampleClamped(
                                            ReflectCoord(sampleX, src.Width),
                                            ReflectCoord(sampleY, src.Height));

                                        break;

                                    case WarpEdgeBehavior.Primary:
                                        sample = colPrimary;
                                        break;

                                    case WarpEdgeBehavior.Secondary:
                                        sample = colSecondary;
                                        break;

                                    case WarpEdgeBehavior.Transparent:
                                        sample = colTransparent;
                                        break;

                                    case WarpEdgeBehavior.Original:
                                        sample = src[x, y];
                                        break;

                                    default:
                                        break;
                                    }
                                }

                                samples[sampleCount] = sample;
                                ++sampleCount;
                            }

                            *dstPtr = ColorBgra.Blend(samples, sampleCount);
                            ++dstPtr;
                        }
                    }
                }
            }
        }
Example #29
0
 /// <summary>
 /// Unit test entry point for complex polygon determination algorithm.
 /// </summary>
 /// <remarks>These entry points exist to allow specific testing of the unsafe algorithms for buffer overruns.</remarks>
 internal static unsafe bool TestIsComplex(PointF *vertices, int vertexCount)
 {
     return(CheckIsComplex(vertices, vertexCount));
 }
Example #30
0
 /// <summary>
 /// Unit test entry point for contains computation algorithm.
 /// </summary>
 /// <remarks>These entry points exist to allow specific testing of the unsafe algorithms for buffer overruns.</remarks>
 internal static unsafe bool TestContains(PointF pt, PointF *vertices, int vertexCount)
 {
     return(CountWindings(pt, vertices, vertexCount) != 0);
 }