C# GDIPlus.GpPointF类代码示例

    Matrix( GpRectF rect, 
            GpPointF[] dstplg)
    {
        GpMatrix matrix;

        lastResult = NativeMethods.GdipCreateMatrix3(rect, 
                                                   dstplg,
                                                   out matrix);

        SetNativeMatrix(matrix);
    }

GdipFillPolygon2(GpGraphics graphics, GpBrush brush,
   GpPointF[] points, int count);

GdipAddPathCurve3(GpPath path, GpPointF[] points, int count,
                           int offset, int numberOfSegments, float tension);

GdipAddPathCurve(GpPath path, GpPointF[] points, int count);

GdipAddPathLine2(GpPath path, GpPointF[] points, int count);

GdipGetPathPoints(GpPath path, GpPointF[] points, int count);

GdipAddPathPolygon(GpPath path, GpPointF[] points, int count);

        public GpStatus DrawImage(ImagePlus image,
                          GpPointF[] destPoints)
        {
            int count = destPoints.Length;

            if (count != 3 && count != 4)
                return SetStatus(GpStatus.InvalidParameter);

            return SetStatus(NativeMethods.GdipDrawImagePoints(nativeGraphics,
                                                             image != null ? image.nativeImage
                                                                   : new GpImage(),
                                                             destPoints, count));
        }

 public GpStatus FillClosedCurve(BrushPlus brush,
                         GpPointF[] points)
 {
     return SetStatus(NativeMethods.GdipFillClosedCurve(nativeGraphics,
                                                      brush.nativeBrush,
                                                      points, points.Length));
 }

 public GpStatus DrawLine(PenPlus pen,
                 GpPointF pt1,
                 GpPointF pt2)
 {
     return DrawLine(pen, pt1.X, pt1.Y, pt2.X, pt2.Y);
 }

 /// <summary>
 ///   Searches the chart to find the index of the pie slice which 
 ///   contains point given. Search order goes in the direction opposite
 ///   to drawing order.
 /// </summary>
 /// <param name="point">
 ///   <c>PointF</c> point for which pie slice is searched for.
 /// </param>
 /// <returns>
 ///   Index of the corresponding pie slice, or -1 if none is found.
 /// </returns>
 public int FindPieSliceUnderPoint(GpPointF point)
 {
     // first check tops
     for (int i = 0; i < m_pieSlices.Length; ++i)
     {
         PieSlice slice = (PieSlice)m_pieSlices[i];
         if (slice.PieSliceContainsPoint(point))
             return (int)m_pieSlicesMapping[i];
     }
     // split the backmost (at 270 degrees) pie slice
     ArrayList pieSlicesList = new ArrayList(m_pieSlices);
     PieSlice[] splitSlices = m_pieSlices[0].Split(270F);
     if (splitSlices.Length > 1)
     {
         pieSlicesList[0] = splitSlices[1];
         if (splitSlices[0].SweepAngle > 0F)
         {
             pieSlicesList.Add(splitSlices[0]);
         }
     }
     PieSlice[] pieSlices = (PieSlice[])pieSlicesList.ToArray(typeof(PieSlice));
     int indexFound = -1;
     // if not found yet, then check for periferies
     int incrementIndex = 0;
     int decrementIndex = pieSlices.Length - 1;
     while (incrementIndex <= decrementIndex)
     {
         PieSlice sliceLeft = pieSlices[decrementIndex];
         float angle1 = 270 - sliceLeft.StartAngle;
         PieSlice sliceRight = pieSlices[incrementIndex];
         float angle2 = (sliceRight.EndAngle + 90) % 360;
         Debug.Assert(angle2 >= 0);
         if (angle2 < angle1)
         {
             if (sliceRight.PeripheryContainsPoint(point))
                 indexFound = incrementIndex;
             ++incrementIndex;
         }
         else
         {
             if (sliceLeft.PeripheryContainsPoint(point))
                 indexFound = decrementIndex;
             --decrementIndex;
         }
     }
     // check for start/stop sides, starting from the foremost
     if (indexFound < 0)
     {
         int foremostPieIndex = GetForemostPieSlice(pieSlices);
         // check for start sides from the foremost slice to the left 
         // side
         int i = foremostPieIndex;
         while (i < pieSlices.Length)
         {
             PieSlice sliceLeft = (PieSlice)pieSlices[i];
             if (sliceLeft.StartSideContainsPoint(point))
             {
                 indexFound = i;
                 break;
             }
             ++i;
         }
         // if not found yet, check end sides from the foremost to the right
         // side
         if (indexFound < 0)
         {
             i = foremostPieIndex;
             while (i >= 0)
             {
                 PieSlice sliceLeft = (PieSlice)pieSlices[i];
                 if (sliceLeft.EndSideContainsPoint(point))
                 {
                     indexFound = i;
                     break;
                 }
                 --i;
             }
         }
     }
     // finally search for bottom sides
     if (indexFound < 0)
     {
         for (int i = 0; i < m_pieSlices.Length; ++i)
         {
             PieSlice slice = (PieSlice)m_pieSlices[i];
             if (slice.BottomSurfaceSectionContainsPoint(point))
                 return (int)m_pieSlicesMapping[i];
         }
     }
//.........这里部分代码省略.........

GdipCreateMatrix3(GpRectF rect, GpPointF[] dstplg,
                       out GpMatrix matrix);

GdipDrawBeziers(GpGraphics graphics, GpPen pen, GpPointF[] points,
          int count);

GdipFillClosedCurve2(GpGraphics graphics, GpBrush brush,
                GpPointF[] points, int count,
               float tension, FillMode fillMode);

GdipFillClosedCurve(GpGraphics graphics, GpBrush brush,
                GpPointF[] points, int count);