如何在Direct2D中画Bezier曲线

Direct2D通过ID2D1RenderTarget接口支持基本图元（直线，矩形，圆角矩形，椭圆等）的绘制，然而，此接口并未提供对曲线绘制的直接支持。因此，想要使用Direct2D绘制一段通过指定点的曲线，比如Bezier曲线，必须借助于DrawGeometry()方法间接实现。需要通过一定的算法，将指定点转换为定义Path的控制点。幸运的是，codproject上已经有人做了这项工作，给出了相应的转换算法，并给出了C#版的实现：

Draw a Smooth Curve through a Set of 2D Points with Bezier Primitives

 

C#的代码可以很容易的转换成C++版本的，下面是我转换的一个用于Direct2D的绘制Bezier曲线的C++函数：

  1: /// <summary>

  2: /// Refer to : http://www.codeproject.com/KB/graphics/BezierSpline.aspx

  3: /// Solves a tridiagonal system for one of coordinates (x or y) of first Bezier control points.

  4: /// </summary>

  5: /// <param name="rhs">Right hand side vector.</param>

  6: /// <param name="x">Solution vector.</param>

  7: void GetFirstControlPoints(

  8:     __in const std::vector<FLOAT>& rhs, 

  9:     __out std::vector<FLOAT>& x )

 10: {

 11:     ATLASSERT(rhs.size()==x.size());

 12:     int n = rhs.size();

 13:     std::vector<FLOAT> tmp(n);    // Temp workspace.

 14: 

 15:     FLOAT b = 2.0f;

 16:     x[0] = rhs[0] / b;

 17:     for (int i = 1; i < n; i++) // Decomposition and forward substitution.

 18:     {

 19:         tmp[i] = 1 / b;

 20:         b = (i < n-1 ? 4.0f : 3.5f) - tmp[i];

 21:         x[i] = (rhs[i] - x[i-1]) / b;

 22:     }

 23:     for (int i = 1; i < n; i++)

 24:     {

 25:         x[n-i-1] -= tmp[n-i] * x[n-i]; // Back substitution.

 26:     }

 27: }

 28: 

 29: /// <summary>

 30: /// Refer to : http://www.codeproject.com/KB/graphics/BezierSpline.aspx

 31: /// Get open-ended Bezier Spline Control Points.

 32: /// </summary>

 33: /// <param name="knots">Input Knot Bezier spline points.</param>

 34: /// <param name="firstCtrlPt">Output First Control points array of knots.size()-1 length.</param>

 35: /// <param name="secondCtrlPt">Output Second Control points array of knots.size()-1 length.</param>

 36: void GetCurveControlPoints(

 37:     __in const std::vector<D2D1_POINT_2F>& knots,

 38:     __out std::vector<D2D1_POINT_2F>& firstCtrlPt, 

 39:     __out std::vector<D2D1_POINT_2F>& secondCtrlPt )

 40: {

 41:     ATLASSERT( (firstCtrlPt.size()==secondCtrlPt.size())

 42:         && (knots.size()==firstCtrlPt.size()+1) );

 43: 

 44:     int n = knots.size()-1;

 45:     ATLASSERT(n>=1);

 46: 

 47:     if (n == 1)

 48:     { 

 49:         // Special case: Bezier curve should be a straight line.

 50:         // 3P1 = 2P0 + P3

 51:         firstCtrlPt[0].x = (2 * knots[0].x + knots[1].x) / 3.0f;

 52:         firstCtrlPt[0].y = (2 * knots[0].y + knots[1].y) / 3.0f;

 53: 

 54:         // P2 = 2P1 – P0

 55:         secondCtrlPt[0].x = 2 * firstCtrlPt[0].x - knots[0].x;

 56:         secondCtrlPt[0].y = 2 * firstCtrlPt[0].y - knots[0].y;

 57:         return;

 58:     }

 59: 

 60:     // Calculate first Bezier control points

 61:     // Right hand side vector

 62:     std::vector<FLOAT> rhs(n);

 63: 

 64:     // Set right hand side X values

 65:     for (int i = 1; i < (n-1); ++i)

 66:     {

 67:         rhs[i] = 4 * knots[i].x + 2 * knots[i+1].x;

 68:     }

 69:     rhs[0] = knots[0].x + 2 * knots[1].x;

 70:     rhs[n-1] = (8 * knots[n-1].x + knots[n].x) / 2.0f;

 71:     // Get first control points X-values

 72:     std::vector<FLOAT> x(n);

 73:     GetFirstControlPoints(rhs,x);

 74: 

 75:     // Set right hand side Y values

 76:     for (int i = 1; i < (n-1); ++i)

 77:     {

 78:         rhs[i] = 4 * knots[i].y + 2 * knots[i+1].y;

 79:     }

 80:     rhs[0] = knots[0].y + 2 * knots[1].y;

 81:     rhs[n-1] = (8 * knots[n-1].y + knots[n].y) / 2.0f;

 82:     // Get first control points Y-values

 83:     std::vector<FLOAT> y(n);

 84:     GetFirstControlPoints(rhs,y);

 85: 

 86:     // Fill output arrays.

 87:     for (int i = 0; i < n; ++i)

 88:     {

 89:         // First control point

 90:         firstCtrlPt[i] = D2D1::Point2F(x[i],y[i]);

 91:         // Second control point

 92:         if (i < (n-1))

 93:         {

 94:             secondCtrlPt[i] = D2D1::Point2F(2 * knots[i+1].x - x[i+1], 2*knots[i+1].y-y[i+1]);

 95:         }

 96:         else

 97:         {

 98:             secondCtrlPt[i] = D2D1::Point2F((knots[n].x + x[n-1])/2, (knots[n].y+y[n-1])/2);

 99:         }

100:     }

101: }

102: 

103: HRESULT CreateBezierSpline(

104:     __in ID2D1Factory* pD2dFactory, 

105:     __in const std::vector<D2D1_POINT_2F>& points,

106:     __out ID2D1PathGeometry** ppPathGeometry )

107: {

108:     CHECK_PTR(pD2dFactory);

109:     CHECK_OUTPUT_PTR(ppPathGeometry);

110:     ATLASSERT(points.size()>1);

111: 

112:     int n = points.size();

113:     std::vector<D2D1_POINT_2F> firstCtrlPt(n-1);

114:     std::vector<D2D1_POINT_2F> secondCtrlPt(n-1);

115:     GetCurveControlPoints(points,firstCtrlPt,secondCtrlPt);

116: 

117:     HRESULT hr = pD2dFactory->CreatePathGeometry(ppPathGeometry);

118:     CHECKHR(hr);

119:     if (FAILED(hr))

120:         return hr;

121: 

122:     CComPtr<ID2D1GeometrySink> spSink;

123:     hr = (*ppPathGeometry)->Open(&spSink);

124:     CHECKHR(hr);

125:     if (SUCCEEDED(hr))

126:     {

127:         spSink->SetFillMode(D2D1_FILL_MODE_WINDING);

128:         spSink->BeginFigure(points[0],D2D1_FIGURE_BEGIN_FILLED);

129:         for (int i=1;i<n;i++)

130:             spSink->AddBezier(D2D1::BezierSegment(firstCtrlPt[i-1],secondCtrlPt[i-1],points[i]));

131:         spSink->EndFigure(D2D1_FIGURE_END_OPEN);

132:         spSink->Close();

133:     }

134:     return hr;

135: }

下面是一个使用此函数绘制正弦函数的Sample，曲线的红点是曲线的控制点：

  1: #pragma once

  2: #include "stdafx.h"

  3: #include <Direct2DHelper.h>

  4: using D2D1::Point2F;

  5: using D2D1::SizeU;

  6: using D2D1::ColorF;

  7: using D2D1::Matrix3x2F;

  8: using D2D1::BezierSegment;

  9: using D2D1::RectF;

 10: 

 11: #include <vector>

 12: using std::vector;

 13: #include <algorithm>

 14: #include <boost/math/distributions/normal.hpp>

 15: 

 16: class CMainWindow :

 17:     public CWindowImpl<CMainWindow,CWindow,CSimpleWinTraits>

 18: {

 19: public:

 20:     BEGIN_MSG_MAP(CMainWindow)

 21:         MSG_WM_PAINT(OnPaint)

 22:         MSG_WM_ERASEBKGND(OnEraseBkgnd)

 23:         MSG_WM_SIZE(OnSize)

 24:         MSG_WM_CREATE(OnCreate)

 25:         MSG_WM_DESTROY(OnDestroy)

 26:     END_MSG_MAP()

 27:     

 28:     int OnCreate(LPCREATESTRUCT /*lpCreateStruct*/)

 29:     {

 30:         CreateDeviceIndependentResource();

 31:         CreateDeviceResource();

 32:         CreateCurve();

 33:         return 0;

 34:     }

 35:     

 36:     void OnDestroy()

 37:     {

 38:         PostQuitMessage(0);

 39:     }

 40:     

 41:     void OnPaint(CDCHandle)

 42:     {

 43:         CPaintDC dc(m_hWnd);

 44:         Render();

 45:     }

 46:     

 47:     BOOL OnEraseBkgnd(CDCHandle dc)

 48:     {

 49:         return TRUE;    // we have erased the background

 50:     }

 51:     

 52:     void OnSize(UINT /*nType*/, CSize size)

 53:     {

 54:         if (m_spHwndRT)

 55:         {

 56:             m_spHwndRT->Resize(SizeU(size.cx,size.cy));

 57:             CreateCurve();

 58:         }

 59:     }

 60: 

 61: private:

 62:     void Render()

 63:     {

 64:         if (!m_spHwndRT)

 65:             CreateDeviceResource();

 66: 

 67:         m_spHwndRT->BeginDraw();

 68:         m_spHwndRT->Clear(ColorF(ColorF::CornflowerBlue));

 69: 

 70:         m_spHwndRT->SetTransform(Matrix3x2F::Identity());

 71: 

 72:         D2D1_SIZE_F size = m_spHwndRT->GetSize();

 73:         FLOAT width = size.width-50, height = size.height-50;

 74:         D2D1_MATRIX_3X2_F reflectY = Direct2DHelper::ReflectYMatrix();

 75:         D2D1_MATRIX_3X2_F translate = Matrix3x2F::Translation(size.width/2.0f,size.height/2.0f);

 76:         m_spHwndRT->SetTransform(reflectY*translate);

 77: 

 78:         // draw coordinate axis

 79:         m_spSolidBrush->SetColor(ColorF(ColorF::Red));

 80:         m_spHwndRT->DrawLine(Point2F(-width*0.5f,0),Point2F(width*0.5f,0),m_spSolidBrush,2.0f);

 81:         m_spSolidBrush->SetColor(ColorF(ColorF::DarkGreen));

 82:         m_spHwndRT->DrawLine(Point2F(0,-height*0.5f),Point2F(0,height*0.5f),m_spSolidBrush,2.0f);

 83: 

 84:         // draw curve

 85:         m_spSolidBrush->SetColor(ColorF(ColorF::Blue));

 86:         m_spHwndRT->DrawGeometry(m_spPathGeometry,m_spSolidBrush,1.0f);

 87: 

 88:         // draw point marks

 89:         m_spSolidBrush->SetColor(ColorF(ColorF::Red));

 90:         for (auto p=m_Points.cbegin();p!=m_Points.cend();p++)

 91:         {

 92:             Direct2DHelper::DrawRectPoint(m_spHwndRT,m_spSolidBrush,(*p),5.0f);

 93:         }

 94: 

 95:         HRESULT hr = m_spHwndRT->EndDraw();

 96:         if (hr == D2DERR_RECREATE_TARGET)

 97:             DiscardDeviceResource();

 98:     }

 99: 

100:     void CreateDeviceIndependentResource()

101:     {

102:         Direct2DHelper::CreateD2D1Factory(&m_spD2dFactory);

103:     }

104: 

105:     void CreateDeviceResource()

106:     {

107:         CRect rc;

108:         GetClientRect(&rc);

109: 

110:         CHECK_PTR(m_spD2dFactory);

111:         IFR(m_spD2dFactory->CreateHwndRenderTarget(

112:             D2D1::RenderTargetProperties(),

113:             D2D1::HwndRenderTargetProperties(m_hWnd,SizeU(rc.Width(),rc.Height())),

114:             &m_spHwndRT));

115:         IFR(m_spHwndRT->CreateSolidColorBrush(ColorF(ColorF::Red),&m_spSolidBrush));

116:     }

117: 

118:     void DiscardDeviceResource()

119:     {

120:         m_spSolidBrush.Release();

121:         m_spHwndRT.Release();

122:     }

123: 

124:     void CreateCurve()

125:     {

126:         if (!m_spHwndRT) 

127:             return;

128:         if (m_spPathGeometry)

129:         {

130:             m_spPathGeometry.Release();

131:             m_Points.clear();

132:         }

133: 

134:         const int ptCount = 100;

135:         D2D1_SIZE_F size = m_spHwndRT->GetSize();

136:         FLOAT width = size.width-50.0f, height = size.height*0.4f;

137: 

138: #define SIN_CURVE    

139: #ifdef SIN_CURVE    // create sin curve

140:         FLOAT factor = static_cast<FLOAT>(4.0f*M_PI/width);

141:         FLOAT x = -width*0.5f, y = 0, dx = width/ptCount;

142:         for (int i=0;i<ptCount+1;i++)

143:         {

144:             y = height*sin(factor*x);

145:             m_Points.push_back(Point2F(x,y));

146:             x += dx;

147:         }

148: #else                // create normal distribute curve

149:         FLOAT factor = 10.0f/width;

150:         FLOAT x = -width*0.5f, y = 0, dx = width/ptCount;

151:         boost::math::normal nd;

152:         for (int i=0;i<ptCount+1;i++)

153:         {

154:             y = height*static_cast<FLOAT>(boost::math::pdf(nd,factor*x));

155:             m_Points.push_back(Point2F(x,y));

156:             x += dx;

157:         }

158: #endif // SIN_CURVE

159: 

160:         // create Bezier spline

161:         Direct2DHelper::CreateBezierSpline(m_spD2dFactory,m_Points,&m_spPathGeometry);

162:         CHECK_PTR(m_spPathGeometry);

163:     }

164: 

165: private:

166:     CComPtr<ID2D1Factory> m_spD2dFactory;

167:     CComPtr<ID2D1HwndRenderTarget> m_spHwndRT;

168:     CComPtr<ID2D1SolidColorBrush> m_spSolidBrush;

169:     CComPtr<ID2D1PathGeometry> m_spPathGeometry;

170: 

171:     vector<D2D1_POINT_2F> m_Points;

172: };