滴水逆向联盟

标题: 基于Visual Studio2012实现Windows8的metro界面笔迹手写识别文档 [打印本页]

---

作者: 大灰狼    时间: 2014-10-11 10:26
标题: 基于Visual Studio2012实现Windows8的metro界面笔迹手写识别文档

手写识别，是指将在手写设备上书写时产生的有序轨迹信息化转化为汉字内码的过程，实际上是手写轨迹的坐标序列到汉字的内码的一个映射过程，是人机交互最自然、最方便的手段之一。 　

　随着智能手机、掌上电脑等移动信息工具的普及，手写识别技术也进入了规模应用时代。 　　

手写识别能够使用户按照最自然、最方便的输入方式进行文字输入，易学易用，可取代键盘或者鼠标。用于手写输入的设备有许多种，比如电磁感应手写板、压感式手写板、触摸屏、触控板、超声波笔等。 　

　手写识别属于文字识别和模式识别范畴，文字识别从识别过程来说分成脱机识别（off-line）和联机识别（on-line)两大类，从识别对象来说又分成手写体识别和印刷体识别两大类，我们常说的手写识别是指联机手写体识别。

下面我们来亲自实践下Windows8下面的笔迹文档开发.

详细请见代码分析

[cpp] view plaincopy

• #include "pch.h"  
• #include <ppltasks.h>  
• #include "simpleInk.h"  
•   
• ///////////////////////////////////////////////////////////////////////////////  
• // simpleInk实施  
•   
•   
• simpleInk::simpleInk(  
•     _In_ Windows::UI::Core::CoreWindow^ window,  
•     _In_ Windows::ApplicationModel::Core::CoreApplicationView^ applicationView)  
• :   _applicationView(applicationView),  
•     _points(nullptr),  
•     _curPointIndex(0),  
•     _pointerId(-1)  
• {  
•     Initialize(window, Windows::Graphics::Display::DisplayProperties::LogicalDpi);  
•   
•     // 设置激活处理程序  
•   
•     _tokenViewActivated = _applicationView->Activated::add(  
•         ref new Windows::Foundation::TypedEventHandler<  
•             Windows::ApplicationModel::Core::CoreApplicationView^,  
•             Windows::ApplicationModel::Activation::IActivatedEventArgs^>(  
•                 this, &simpleInk::OnViewActivated));  
•   
•     // 设置窗口的事件处理程序  
•   
•     m_window->PointerCursor = ref new Windows::UI::Core::CoreCursor(  
•         Windows::UI::Core::CoreCursorType::Arrow, 0);  
•   
•     _tokenWindowActivated = m_window->Activated::add(  
•         ref new Windows::Foundation::TypedEventHandler<  
•             Windows::UI::Core::CoreWindow^, Windows::UI::Core::WindowActivatedEventArgs^>(  
•                 this, &simpleInk::OnWindowActivated));  
•   
•     _tokenWindowSizeChanged = m_window->SizeChanged::add(  
•         ref new Windows::Foundation::TypedEventHandler<  
•             Windows::UI::Core::CoreWindow^, Windows::UI::Core::WindowSizeChangedEventArgs^>(  
•                 this, &simpleInk::OnWindowSizeChanged));  
•   
•     _tokenCharacterReceived = m_window->CharacterReceived::add(  
•         ref new Windows::Foundation::TypedEventHandler<  
•             Windows::UI::Core::CoreWindow^, Windows::UI::Core::CharacterReceivedEventArgs^>(  
•                 this, &simpleInk::OnCharacterReceived));  
•   
•     _tokenPointerPressed = m_window->PointerPressed::add(  
•         ref new Windows::Foundation::TypedEventHandler<  
•             Windows::UI::Core::CoreWindow^, Windows::UI::Core::PointerEventArgs^>(  
•                 this, &simpleInk::OnPointerPressed));  
•   
•     _tokenPointerMoved = m_window->PointerMoved::add(  
•         ref new Windows::Foundation::TypedEventHandler<  
•             Windows::UI::Core::CoreWindow^, Windows::UI::Core::PointerEventArgs^>(  
•                 this, &simpleInk::OnPointerMoved));  
•   
•     _tokenPointerReleased = m_window->PointerReleased::add(  
•         ref new Windows::Foundation::TypedEventHandler<  
•             Windows::UI::Core::CoreWindow^, Windows::UI::Core::PointerEventArgs^>(  
•                 this, &simpleInk::OnPointerReleased));  
•   
•     _recognitionText = "";  
•   
•     _strokeBuilder = ref new Windows::UI::Input::Inking::InkStrokeBuilder();  
•     _strokeContainer = ref new Windows::UI::Input::Inking::InkStrokeContainer();  
•     _recognizerContainer = ref new Windows::UI::Input::Inking::InkRecognizerContainer();  
•   
•     // 检测识别引擎并将第一个为默认  
•   
•     _recognizerId = 0;  
•     _recognizer = _recognizerContainer->GetRecognizers()->GetAt(_recognizerId);  
•     _recognizerContainer->SetDefaultRecognizer(_recognizer);  
•   
•     _drawingAttributes = ref new Windows::UI::Input::Inking::InkDrawingAttributes();  
•     _drawingAttributes->Color = Windows::UI::Colors::Black;  
•     _drawingAttributes->PenTip = Windows::UI::Input::Inking::PenTipShape::Circle;  
•     Windows::Foundation::Size size;  
•     size.Width = 3.0f;  
•     _drawingAttributes->Size = size;  
•     _drawingAttributes->IgnorePressure = true;  
•     _drawingAttributes->FitToCurve = true;  
•   
•     _strokeBuilder->SetDefaultDrawingAttributes(_drawingAttributes);  
•   
•     CreateBrush(_drawingAttributes->Color, &_currentBrush);  
• }  
•   
• simpleInk::~simpleInk()  
• {  
•     // Remove all the window event handlers  
•     m_window->Activated::remove(_tokenWindowActivated);  
•     m_window->SizeChanged::remove(_tokenWindowSizeChanged);  
•     m_window->CharacterReceived::remove(_tokenCharacterReceived);  
•     m_window->PointerPressed::remove(_tokenPointerPressed);  
•     m_window->PointerMoved::remove(_tokenPointerMoved);  
•     m_window->PointerReleased::remove(_tokenPointerReleased);  
•     m_window->PointerWheelChanged::remove(_tokenPointerWheelChanged);  
•   
•     // 删除所有窗口的事件处理程序  
•   
•     _applicationView->Activated::remove(_tokenViewActivated);  
•   
•     // 除视图激活处理程序  
•   
•     m_d2dContext->SetTarget(nullptr);  
•     m_d2dContext = nullptr;  
•     m_d2dDevice = nullptr;  
•     m_d2dFactory = nullptr;  
•     m_d2dTargetBitmap = nullptr;  
•     m_d3dContext = nullptr;  
•     m_d3dDevice = nullptr;  
•     m_depthStencilView = nullptr;  
•     m_dwriteFactory = nullptr;  
•     m_renderTargetView = nullptr;  
•     m_swapChain = nullptr;  
•     m_wicFactory = nullptr;  
•     _blackBrush = nullptr;  
•     _currentBrush = nullptr;  
•     _eventTextFormat = nullptr;  
•   
•     _points = nullptr;  
•   
•     _recognitionText = nullptr;  
•   
•     _strokeBuilder = nullptr;  
•     _strokeContainer = nullptr;  
•     _recognizerContainer = nullptr;  
•     _recognizer = nullptr;  
•     _drawingAttributes = nullptr;  
• }  
•   
• void simpleInk::Run()  
• {  
•     // 激活窗口，以便将可见。  
•     m_window->Activate();  
•   
•     // 处理所有的事件，如果存在  
•   
•     m_window->Dispatcher->ProcessEvents(Windows::UI::Core::CoreProcessEventsOption::ProcessUntilQuit);  
• }  
•   
• //  
• // 视图激活处理程序中的应用  
•   
• //  
• void simpleInk::OnViewActivated(_In_ Windows::ApplicationModel::Core::CoreApplicationView^, _In_ Windows::ApplicationModel::Activation::IActivatedEventArgs^)  
• {  
•     m_window->Activate();  
• }  
•   
• //  
• // 事件处理程序  
• //  
• void simpleInk::OnWindowActivated(_In_ Windows::UI::Core::CoreWindow^, _In_ Windows::UI::Core::WindowActivatedEventArgs^)  
• {  
•     RenderOnAllBuffers();  
• }  
•   
• void simpleInk::OnWindowSizeChanged(_In_ Windows::UI::Core::CoreWindow^, _In_ Windows::UI::Core::WindowSizeChangedEventArgs^)  
• {  
•     UpdateForWindowSizeChange();  
•     RenderOnAllBuffers();  
• }  
•   
• void simpleInk::OnCharacterReceived(_In_ Windows::UI::Core::CoreWindow^, _In_ Windows::UI::Core::CharacterReceivedEventArgs^ args)  
• {  
•     switch (args->KeyCode)  
•     {  
•     case 3: // ctrl+c 复制处理程序  
•   
•         OnCopyToClipboard();  
•         break;  
•     case 20: // ctrl+t, 复制文字处理程序  
•         OnCopyTextToClipboard();  
•         break;  
•     case 22: // ctrl+v, 粘贴处理程序  
•   
•         OnPasteFromClipboard();  
•         break;  
•     case 19: // ctrl+s, 保存处理程序  
•         OnSave();  
•         break;  
•     case 15: // ctrl+o,公开处理程序  
•   
•         OnLoad();  
•         break;  
•     case 1: // ctrl+a, 选择所有的处理程序  
•   
•         OnSelectAll();  
•         break;  
•     case 8: //退格，删除处理程序  
•   
•         OnDelete();  
•         break;  
•     case 4: // crtl+d, 更改绘图属性  
•   
•         OnChangeDrawingAttributes();  
•         break;  
•     case 18: // crtl+r, 改变识别引擎  
•         OnChangeRecognizer();  
•         break;  
•     case 32: // space, 识别  
•         OnRecognize();  
•         break;  
•     }  
• }  
•   
• void simpleInk::OnPointerPressed(_In_ Windows::UI::Core::CoreWindow^, _In_ Windows::UI::Core::PointerEventArgs^ args)  
• {  
•     Windows::UI::Input::PointerPoint^ pointerPoint = args->CurrentPoint;  
•   
•     //确保没有指针已经是墨（我们允许在一个时间只有一个“积极的”指针）  
•   
•     //确保指针在墨模式（笔，没有按钮，或鼠标左键下）  
•   
•     if (_pointerId == -1 && PointerIsInking(pointerPoint))  
•     {     
•         // 笔迹书写第一点  
•         _strokeBuilder->BeginStroke(pointerPoint);  
•   
•         // 初始化变量用来保持轨道线呈现在不同的缓冲区.  
•         // 欲了解更多信息的地方是在头文件中声明_points看到评论e.  
•         _points = ref new Platform::Array<Windows::UI::Input::PointerPoint^>(NUM_BUFFERS + 1);  
•         _curPointIndex = 0;  
•         _points[_curPointIndex] = pointerPoint;  
•   
•         _pointerId = pointerPoint->PointerId; // save pointer id so that no other pointer can ink until this one it is released  
•     }  
• }  
•   
• void simpleInk::OnPointerMoved(_In_ Windows::UI::Core::CoreWindow^, _In_ Windows::UI::Core::PointerEventArgs^ args)  
• {   
•     Windows::UI::Input::PointerPoint^ pointerPoint = args->CurrentPoint;  
•   
•     // 确保开始书写  
•     if (_pointerId == (int) pointerPoint->PointerId)  
•     {  
•         // 取中间点  
•         Windows::Foundation::Collections::IVector<Windows::UI::Input::PointerPoint^>^ pointerPoints = args->GetIntermediatePoints();  
•   
•         // 更新笔迹  
•         for (unsigned int i = 0; i < pointerPoints->Size; i++)  
•         {  
•             _strokeBuilder->AppendToStroke(pointerPoints->GetAt(i));  
•         }  
•   
•         // 实时渲染  
•   
•         // 保存新的起点，并呈现新线，以及线提供的其他缓冲区。  
•   
•         _curPointIndex = (_curPointIndex + 1) % _points->Length;  
•         _points[_curPointIndex] = pointerPoint;  
•         for (unsigned int i = 1; i < _points->Length; i++)  
•         {  
•             unsigned int si = (i + _curPointIndex) % _points->Length;  
•             unsigned int ei = (si + 1) % _points->Length;  
•             if (nullptr != _points[si] && nullptr != _points[ei])  
•             {  
•                 RenderLine(_points[si]->Position, _points[ei]->Position);  
•             }  
•         }  
•         Present();  
•     }  
• }  
•   
• void simpleInk::OnPointerReleased(_In_ Windows::UI::Core::CoreWindow^, _In_ Windows::UI::Core::PointerEventArgs^ args)  
• {  
•     Windows::UI::Input::PointerPoint^ pointerPoint = args->CurrentPoint;  
•   
•     // 确保该事件属于指针  
•     if (_pointerId == (int) pointerPoint->PointerId)  
•     {  
•         //这是最后一点  
•         Windows::UI::Input::Inking::InkStroke^ stroke = _strokeBuilder->EndStroke(pointerPoint);  
•       
•         //添加笔迹容器  
•   
•         _strokeContainer->AddStroke(stroke);  
•   
•         // 准备好了，没有实时渲染的需要，重新渲染整个场景  
•         RenderOnAllBuffers();  
•   
•         // 改变未来中风的颜色和宽度  
•         OnChangeDrawingAttributes();  
•   
•         _points = nullptr; // 退出实时模式  
•         _pointerId = -1;   //退出时删除对象  
•     }  
• }  
•   
• void simpleInk::OnCopyToClipboard()  
• {  
•    
•     Windows::Foundation::Collections::IVectorView<Windows::UI::Input::Inking::IInkStroke^>^ inkStrokes = _strokeContainer->GetStrokes();  
•   
•     bool someSelected = false;  
•     for(unsigned int i = 0; i < inkStrokes->Size; i++)  
•     {  
•         if (inkStrokes->GetAt(i)->Selected)  
•         {  
•    
•             someSelected = true;  
•             break;  
•         }  
•     }  
•   
•   
•     if (someSelected)  
•     {  
•         
•         _strokeContainer->CopySelectedToClipboard();  
•     }  
•     else  
•     {  
•   
•    
•         for(unsigned int i = 0; i < inkStrokes->Size; i++)  
•         {  
•             inkStrokes->GetAt(i)->Selected = true;  
•         }  
•   
•   
•         _strokeContainer->CopySelectedToClipboard();  
•   
•   
•         for(unsigned int i = 0; i < inkStrokes->Size; i++)  
•         {  
•             inkStrokes->GetAt(i)->Selected = false;  
•         }  
•     }  
• }  
•   
• void simpleInk::OnCopyTextToClipboard()  
• {  
•   
•     Windows::ApplicationModel::DataTransfer::DataPackage^ dataPackage = ref new Windows::ApplicationModel::DataTransfer::DataPackage();  
•   
•     dataPackage->SetText(_recognitionText);  
•   
•     Windows::ApplicationModel::DataTransfer::Clipboard::SetContent(dataPackage);  
• }  
•   
• void simpleInk::OnPasteFromClipboard()  
• {  
•    
•     bool canPaste = _strokeContainer->CanPasteFromClipboard();  
•     if (canPaste)  
•     {  
•      
•         Windows::Foundation::Point position;  
•         position.X = 100.0f;  
•         position.Y = 100.0f;  
•   
•         _strokeContainer->PasteFromClipboard(position);  
•   
•         RenderOnAllBuffers();  
•     }  
•     else   
•     {  
•   
•     }  
• }  
•   
•   
• void simpleInk::OnSave()  
• {  
•     Windows::Storage::Pickers::FileSavePicker^ savePicker = ref new Windows::Storage::Pickers::FileSavePicker();  
•     savePicker->SuggestedStartLocation = Windows::Storage::Pickers::PickerLocationId::PicturesLibrary;  
•   
•     auto extension = ref new Platform::Collections::Vector<Platform::String^>;  
•     extension->Append(".gif");  
•     savePicker->FileTypeChoices->Insert("Gif with embedded ISF", extension);  
•   
•     savePicker->DefaultFileExtension = ".gif";  
•   
•     concurrency::task<Windows::Storage::StorageFile^> savePickerTask(savePicker->PickSaveFileAsync());  
•     savePickerTask.then([this] (Windows::Storage::StorageFile^ file)  
•     {  
•         
•         if (nullptr != file)  
•         {  
•             concurrency::task<Windows::Storage::Streams::IRandomAccessStream^> openFileTask(file->OpenAsync(Windows::Storage::FileAccessMode::ReadWrite));  
•             openFileTask.then([this] (Windows::Storage::Streams::IRandomAccessStream^ stream)  
•             {  
•            
•                 concurrency::task<unsigned int> saveTask(_strokeContainer->SaveAsync(stream));  
•                 saveTask.then([stream] (unsigned int)  
•                 {  
•                     concurrency::task<bool> flushTask(stream->FlushAsync());  
•                     flushTask.then([] (bool)  
•                     {  
•                             // done!  
•                     });  
•                 });  
•             });  
•         }  
•     });  
• }  
•   
• void simpleInk::OnLoad()  
• {  
•     Windows::Storage::Pickers::FileOpenPicker^ openPicker = ref new Windows::Storage::Pickers::FileOpenPicker();  
•     openPicker->SuggestedStartLocation = Windows::Storage::Pickers::PickerLocationId::PicturesLibrary;  
•     openPicker->FileTypeFilter->Append(".gif");  
•   
•     concurrency::task<Windows::Storage::StorageFile^> openPickerTask(openPicker->PickSingleFileAsync());  
•     openPickerTask.then([this] (Windows::Storage::StorageFile^ file)  
•     {  
•          
•         if (nullptr != file)  
•         {  
•             concurrency::task<Windows::Storage::Streams::IRandomAccessStream^> openFileTask(file->OpenAsync(Windows::Storage::FileAccessMode::Read));  
•             openFileTask.then([this] (Windows::Storage::Streams::IRandomAccessStream^ stream)  
•             {  
•   
•                 concurrency::task<void> loadTask(_strokeContainer->LoadAsync(stream));  
•                 loadTask.then([this] (void)  
•                 {  
•                     RenderOnAllBuffers();  
•                 });  
•             });  
•         }  
•     });  
• }  
•   
• void simpleInk::OnSelectAll()  
• {  
•   
•     Windows::Foundation::Collections::IVectorView<Windows::UI::Input::Inking::IInkStroke^>^ inkStrokes = _strokeContainer->GetStrokes();  
•   
•     for(unsigned int i = 0; i < inkStrokes->Size; i++)  
•     {  
•         inkStrokes->GetAt(i)->Selected = true;  
•     }  
•   
•     RenderOnAllBuffers();  
• }  
•   
• void simpleInk::OnDelete()  
• {  
•   
•     Windows::Foundation::Collections::IVectorView<Windows::UI::Input::Inking::IInkStroke^>^ inkStrokes = _strokeContainer->GetStrokes();  
•   
•     bool someSelected = false;  
•     for(unsigned int i = 0; i < inkStrokes->Size; i++)  
•     {  
•         if (inkStrokes->GetAt(i)->Selected)  
•         {  
•   
•             someSelected = true;  
•             break;  
•         }  
•     }  
•   
•     if (someSelected)  
•     {  
•   
•         _strokeContainer->DeleteSelected();  
•     }  
•     else  
•     {  
•   
•         for(unsigned int i = 0; i < inkStrokes->Size; i++)  
•         {  
•             inkStrokes->GetAt(i)->Selected = true;  
•         }  
•   
•         _strokeContainer->DeleteSelected();  
•     }  
•   
•     RenderOnAllBuffers();  
• }  
•   
• void simpleInk::OnChangeDrawingAttributes()  
• {  
•   
•     _drawingAttributes->Color = Windows::UI::ColorHelper::FromArgb(255, rand() & 0xf0, rand() & 0xf0, rand() & 0xf0);  
•   
•   
•     Windows::Foundation::Size size;  
•     size.Width = (rand() & 0x07) * 1.0f + 1.0f;   
•     _drawingAttributes->Size = size;  
•   
•     _strokeBuilder->SetDefaultDrawingAttributes(_drawingAttributes);  
•   
•   
•     CreateBrush(_drawingAttributes->Color, &_currentBrush);  
• }  
•   
• void simpleInk::OnChangeRecognizer()  
• {  
•   
•     _recognizerId++;  
•       
•   
•     if (_recognizerId >= _recognizerContainer->GetRecognizers()->Size)  
•     {  
•         _recognizerId = 0;  
•     }  
•   
•     _recognizerContainer->SetDefaultRecognizer(_recognizerContainer->GetRecognizers()->GetAt(_recognizerId));  
•   
•   
•     RenderOnAllBuffers();  
• }  
•   
• void simpleInk::OnRecognize()  
• {  
•    
•   
•     _recognitionText = "";  
•   
•   
•     Windows::Foundation::Collections::IVectorView<Windows::UI::Input::Inking::IInkStroke^>^ inkStrokes = _strokeContainer->GetStrokes();  
•   
•   
•     if (0 == inkStrokes->Size)  
•     {  
•         RenderOnAllBuffers();   
•         return;  
•     }  
•   
•     Windows::UI::Input::Inking::InkRecognitionTarget target = Windows::UI::Input::Inking::InkRecognitionTarget::All;  
•     for(unsigned int i = 0; i < inkStrokes->Size; i++)  
•     {  
•         if (inkStrokes->GetAt(i)->Selected)  
•         {  
•   
•             target = Windows::UI::Input::Inking::InkRecognitionTarget::Selected;  
•             break;  
•         }  
•     }  
•   
•   
•     concurrency::task<Windows::Foundation::Collections::IVectorView<Windows::UI::Input::Inking::IInkRecognitionResult^>^> recognizeTask(_recognizerContainer->RecognizeAsync(_strokeContainer, target));  
•     recognizeTask.then([this] (Windows::Foundation::Collections::IVectorView<Windows::UI::Input::Inking::IInkRecognitionResult^>^ recognitionResults)  
•     {  
•      
•         _strokeContainer->UpdateRecognitionResults(recognitionResults);  
•          
•   
•         Windows::Foundation::Collections::IVectorView<Windows::UI::Input::Inking::IInkRecognitionResult^>^ updatedRecognitionResults = _strokeContainer->GetRecognitionResults();  
•         for(unsigned int i = 0; i < updatedRecognitionResults->Size; i++)  
•         {  
•      
•             Windows::UI::Input::Inking::IInkRecognitionResult^ recognitionResult = updatedRecognitionResults->GetAt(i);  
•   
•      
•             Windows::Foundation::Collections::IVectorView<Platform::String^>^ textCandidates = recognitionResult->GetTextCandidates();  
•   
•         
•             Platform::String^ topCandidate = textCandidates->GetAt(0);  
•   
•   
•             _recognitionText += topCandidate + " ";  
•         }  
•   
•   
•         RenderOnAllBuffers();  
•     });  
• }  
•   
• void simpleInk::RenderLine(Windows::Foundation::Point from, Windows::Foundation::Point to)  
• {  
•   
•     m_d2dContext->BeginDraw();  
•     m_d2dContext->SetTransform(D2D1::Matrix3x2F::Identity());  
•   
•   
•     float width = _drawingAttributes->Size.Width;  
•   
•     m_d2dContext->DrawLine(D2D1::Point2F(from.X, from.Y), D2D1::Point2F(to.X, to.Y), _currentBrush.Get(), width, (ID2D1StrokeStyle *) 0);  
•   
•     HRESULT hr = m_d2dContext->EndDraw();  
•     if (hr == D2DERR_RECREATE_TARGET)  
•     {  
•         m_d2dContext->SetTarget(nullptr);  
•         m_d2dTargetBitmap = nullptr;  
•         CreateWindowSizeDependentResources();  
•     }  
•     else  
•     {  
•         DX::ThrowIfFailed(hr);  
•     }  
•   
• }  
•   
•   
• void simpleInk::ConvertStrokeToGeometry(_In_ Windows::UI::Input::Inking::IInkStroke^ stroke, _Outptr_ ID2D1PathGeometry** geometry)  
• {  
•   
•     DX::ThrowIfFailed(m_d2dFactory->CreatePathGeometry(geometry));  
•   
•     Microsoft::WRL::ComPtr<ID2D1GeometrySink> sink;  
•     DX::ThrowIfFailed((*geometry)->Open(&sink));  
•     sink->SetSegmentFlags(D2D1_PATH_SEGMENT_FORCE_ROUND_LINE_JOIN);  
•     sink->SetFillMode(D2D1_FILL_MODE_ALTERNATE);  
•   
•     Windows::Foundation::Collections::IVectorView<Windows::UI::Input::Inking::IInkStrokeRenderingSegment^>^ renderingSegments = stroke->GetRenderingSegments();  
•   
•     Windows::UI::Input::Inking::IInkStrokeRenderingSegment^ firstSegment = renderingSegments->GetAt(0);  
•     Windows::Foundation::Point first = firstSegment->Position;  
•     sink->BeginFigure(D2D1::Point2F(first.X, first.Y), D2D1_FIGURE_BEGIN_FILLED);  
•   
•   
•     for (unsigned int j = 1; j < renderingSegments->Size; j++)  
•     {  
•    
•         Windows::UI::Input::Inking::IInkStrokeRenderingSegment^ renderingSegment = renderingSegments->GetAt(j);  
•   
•         sink->AddBezier(  
•             D2D1::BezierSegment(  
•                 D2D1::Point2F(renderingSegment->BezierControlPoint1.X, renderingSegment->BezierControlPoint1.Y),  
•                 D2D1::Point2F(renderingSegment->BezierControlPoint2.X, renderingSegment->BezierControlPoint2.Y),  
•                 D2D1::Point2F(renderingSegment->Position.X, renderingSegment->Position.Y)  
•                 )  
•             );  
•     }  
•   
•   
•     sink->EndFigure(D2D1_FIGURE_END_OPEN);  
•     DX::ThrowIfFailed(sink->Close());  
• }  
•   
•   
• void simpleInk::OnRender()  
• {  
•     // drawing  
•     m_d2dContext->BeginDraw();  
•     m_d2dContext->SetTransform(D2D1::Matrix3x2F::Identity());  
•     m_d2dContext->Clear(D2D1::ColorF(D2D1::ColorF::White));  
•   
•     // render all strokes  
•     Windows::Foundation::Collections::IVectorView<Windows::UI::Input::Inking::IInkStroke^>^ inkStrokes = _strokeContainer->GetStrokes();  
•     for(unsigned int i = 0; i < inkStrokes->Size; i++)  
•     {  
•         
•         Windows::UI::Input::Inking::IInkStroke^ stroke = inkStrokes->GetAt(i);  
•   
•         Microsoft::WRL::ComPtr<ID2D1PathGeometry> strokeGeometry;  
•         ConvertStrokeToGeometry(stroke, &strokeGeometry);  
•   
•         
•         float width = stroke->DrawingAttributes->Size.Width;  
•         int color = RGB(stroke->DrawingAttributes->Color.R, stroke->DrawingAttributes->Color.G, stroke->DrawingAttributes->Color.B);  
•   
•      
•         Microsoft::WRL::ComPtr<ID2D1SolidColorBrush> currentBrush;  
•         DX::ThrowIfFailed(m_d2dContext->CreateSolidColorBrush(D2D1::ColorF(color), ¤tBrush));  
•   
•         m_d2dContext->DrawGeometry(strokeGeometry.Get(), currentBrush.Get(), width, (ID2D1StrokeStyle *) 0);  
•     }  
•   
•   
•     D2D1_RECT_F recoTextRect = {0, 50, 1000, 500};  
•     m_d2dContext->DrawText(_recognitionText->Begin(), _recognitionText->Length(), _eventTextFormat.Get(), &recoTextRect, _blackBrush.Get());  
•   
•   
•     D2D1_RECT_F recoNameRect = {0, 0, 1000, 500};  
•     Platform::String^ name = _recognizerContainer->GetRecognizers()->GetAt(_recognizerId)->Name;  
•     m_d2dContext->DrawText(name->Begin(), name->Length(), _eventTextFormat.Get(), &recoNameRect, _blackBrush.Get());  
•   
•     HRESULT hr = m_d2dContext->EndDraw();  
•     if (hr == D2DERR_RECREATE_TARGET)  
•     {  
•         m_d2dContext->SetTarget(nullptr);  
•         m_d2dTargetBitmap = nullptr;  
•         CreateWindowSizeDependentResources();  
•     }  
•     else  
•     {  
•         DX::ThrowIfFailed(hr);  
•     }  
•   
•     Present();  
• }  
•   
•   
• void simpleInk::RenderOnAllBuffers()  
• {  
•     for (unsigned int i = 0; i < NUM_BUFFERS; i++)  
•     {  
•         OnRender();  
•     }  
• }  
•   
• void simpleInk::CreateBrush(_In_ Windows::UI::Color color, _Outptr_ ID2D1SolidColorBrush** brush)  
• {  
•     int iColor = RGB(color.R, color.G, color.B);  
•     *brush = nullptr;  
•     DX::ThrowIfFailed(  
•         m_d2dContext->CreateSolidColorBrush(  
•             D2D1::ColorF(iColor),  
•             brush  
•             )  
•         );  
• }  
•   
•   
•   
• void simpleInk::CreateDeviceResources()  
• {  
•     DirectXBase::CreateDeviceResources();  
•   
•    
•     DX::ThrowIfFailed(  
•         m_dwriteFactory->CreateTextFormat(L"Verdana", NULL, DWRITE_FONT_WEIGHT_NORMAL,  
•             DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, 20.0f, L"",  
•             &_eventTextFormat));  
•   
•     _eventTextFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_LEADING);  
•     _eventTextFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_NEAR);  
•   
•     CreateBrush(Windows::UI::Colors::Black, &_blackBrush);  
• }  
•   
• void simpleInk::CreateWindowSizeDependentResources()  
• {  
•    
•     m_windowBounds = m_window->Bounds;  
•   
•     // If the swap chain already exists, resize it.  
•     if(m_swapChain != nullptr)  
•     {  
•         DX::ThrowIfFailed(  
•             m_swapChain->ResizeBuffers(NUM_BUFFERS, 0, 0, DXGI_FORMAT_B8G8R8A8_UNORM, 0)  
•             );  
•     }  
•     // Otherwise, create a new one.  
•     else  
•     {  
•         // Allocate a descriptor.  
•         DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};  
•         swapChainDesc.Width = 0;                                       
•         swapChainDesc.Height = 0;  
•         swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;            
•         swapChainDesc.Stereo = false;   
•         swapChainDesc.SampleDesc.Count = 1;                           
•         swapChainDesc.SampleDesc.Quality = 0;  
•         swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;  
•         swapChainDesc.BufferCount = NUM_BUFFERS;                     
•         swapChainDesc.Scaling = DXGI_SCALING_NONE;  
•         swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;   
•         swapChainDesc.Flags = 0;  
•   
•       
•   
•         Microsoft::WRL::ComPtr<IDXGIDevice1>  dxgiDevice;  
•         DX::ThrowIfFailed(  
•             m_d3dDevice.As(&dxgiDevice)  
•             );  
•   
•         Microsoft::WRL::ComPtr<IDXGIAdapter> dxgiAdapter;  
•         DX::ThrowIfFailed(  
•             dxgiDevice->GetAdapter(&dxgiAdapter)  
•             );  
•   
•   
•         Microsoft::WRL::ComPtr<IDXGIFactory2> dxgiFactory;  
•         DX::ThrowIfFailed(  
•             dxgiAdapter->GetParent(  
•                 __uuidof(IDXGIFactory2),   
•                 &dxgiFactory  
•                 )  
•             );  
•   
•         DX::ThrowIfFailed(  
•             dxgiFactory->CreateSwapChainForCoreWindow(  
•                 m_d3dDevice.Get(),  
•                 reinterpret_cast<IUnknown*>(m_window),  
•                 &swapChainDesc,  
•                 nullptr,     
•                 &m_swapChain  
•                 )  
•             );  
•   
•          
•         DX::ThrowIfFailed(  
•             dxgiDevice->SetMaximumFrameLatency(MAX_FRAME_LATENCY)  
•             );  
•   
•     }  
•   
•     Microsoft::WRL::ComPtr<ID3D11Texture2D> backBuffer;  
•     DX::ThrowIfFailed(  
•         m_swapChain->GetBuffer(  
•             0,  
•             __uuidof(ID3D11Texture2D),  
•             &backBuffer  
•             )  
•         );  
•   
•   
•     DX::ThrowIfFailed(  
•         m_d3dDevice->CreateRenderTargetView(  
•             backBuffer.Get(),  
•             nullptr,  
•             &m_renderTargetView  
•             )  
•         );  
•   
•     D3D11_TEXTURE2D_DESC backBufferDesc = {0};  
•     backBuffer->GetDesc(&backBufferDesc);  
•     m_renderTargetSize.Width  = static_cast<float>(backBufferDesc.Width);  
•     m_renderTargetSize.Height = static_cast<float>(backBufferDesc.Height);  
•   
•   
•     CD3D11_TEXTURE2D_DESC depthStencilDesc(  
•         DXGI_FORMAT_D24_UNORM_S8_UINT,   
•         backBufferDesc.Width,  
•         backBufferDesc.Height,  
•         1,  
•         1,  
•         D3D11_BIND_DEPTH_STENCIL  
•         );  
•   
•   
•     Microsoft::WRL::ComPtr<ID3D11Texture2D> depthStencil;  
•     DX::ThrowIfFailed(  
•         m_d3dDevice->CreateTexture2D(  
•             &depthStencilDesc,  
•             nullptr,  
•             &depthStencil  
•             )  
•         );  
•   
•     DX::ThrowIfFailed(  
•         m_d3dDevice->CreateDepthStencilView(  
•             depthStencil.Get(),  
•             &CD3D11_DEPTH_STENCIL_VIEW_DESC(D3D11_DSV_DIMENSION_TEXTURE2D),  
•             &m_depthStencilView  
•             )  
•         );  
•   
•    
•     CD3D11_VIEWPORT viewport(  
•         0.0f,  
•         0.0f,  
•         static_cast<float>(backBufferDesc.Width),  
•         static_cast<float>(backBufferDesc.Height)  
•         );  
•   
•   
•     m_d3dContext->RSSetViewports(1, &viewport);  
•   
•    
•     D2D1_BITMAP_PROPERTIES1 bitmapProperties =   
•         D2D1::BitmapProperties1(  
•             D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW,  
•             D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED),  
•             m_dpi,  
•             m_dpi  
•             );  
•   
•   
•     Microsoft::WRL::ComPtr<IDXGISurface> dxgiBackBuffer;  
•     DX::ThrowIfFailed(  
•         m_swapChain->GetBuffer(  
•             0,  
•             __uuidof(IDXGISurface),  
•             &dxgiBackBuffer  
•             )  
•         );  
•   
•   
•     DX::ThrowIfFailed(  
•         m_d2dContext->CreateBitmapFromDxgiSurface(  
•             dxgiBackBuffer.Get(),  
•             &bitmapProperties,  
•             &m_d2dTargetBitmap  
•             )  
•         );  
•   
•   
•     m_d2dContext->SetTarget(m_d2dTargetBitmap.Get());  
•   
•     m_d2dContext->SetTextAntialiasMode(D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE);  
• }  
•   
• void simpleInk::Present()  
• {  
•     // 设置写字的参数  
•     DXGI_PRESENT_PARAMETERS parameters = {0};  
•     parameters.DirtyRectsCount = 0;  
•     parameters.pDirtyRects = nullptr;  
•     parameters.pScrollRect = nullptr;  
•     parameters.pScrollOffset = nullptr;  
•       
•     // 设置窗口句柄  
•     HRESULT hr = m_swapChain->Present1(0, 0, &para;meters);  
•   
•     // 如果设备没有准备好,将返回失败  
•     if (hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET)  
•     {  
•         Initialize(m_window, m_dpi);  
•     }  
•     else  
•     {  
•         DX::ThrowIfFailed(hr);  
•     }  
• }  
•   
• ///////////////////////////////////////////////////////////////////////////////  
• // 视图框架  
•   
• simpleInkFrameworkView::simpleInkFrameworkView()  
• :   _activationEntryPoint(ActivationEntryPoint::Unknown),  
• _window(nullptr),  
• _applicationView(nullptr)  
• {  
• }  
•   
• void simpleInkFrameworkView::Initialize(_In_ Windows::ApplicationModel::Core::CoreApplicationView^ applicationView)  
• {  
•     // 初始化程序视图  
•     _applicationView = applicationView;  
• }  
•   
• void simpleInkFrameworkView::SetWindow(_In_ Windows::UI::Core::CoreWindow^ window)  
• {  
•     // 设置窗口句柄  
•     _window = window;  
• }  
•   
• void simpleInkFrameworkView::Load(Platform::String^ entryPoint)  
• {  
•     if (entryPoint == "simpleInk.App")  
•     {  
•         _activationEntryPoint = ActivationEntryPoint::simpleInk;  
•     }  
• }  
•   
• void simpleInkFrameworkView::Run()  
• {  
•     if (_activationEntryPoint == ActivationEntryPoint::simpleInk)  
•     {  
•         simpleInk^ view = ref new simpleInk(_window, _applicationView);  
•         view->Run();  
•     }  
•     else  
•     {  
•         DX::ThrowIfFailed(E_UNEXPECTED);  
•     }  
• }  
•   
• void simpleInkFrameworkView::Uninitialize()  
• {  
• }  
•   
•   
• Windows::ApplicationModel::Core::IFrameworkView^ simpleInkFrameworkViewSource::CreateView()  
• {  
•     return ref new simpleInkFrameworkView();  
• }  
•   
• ///////////////////////////////////////////////////////////////////////////////  
• // 程序入口  
•   
• // 程序初始化  
• [Platform::MTAThread]  
• int main(Platform::Array<Platform::String^>^)  
• {  
•     auto frameworkViewSource = ref new simpleInkFrameworkViewSource();  
•     return Windows::ApplicationModel::Core::CoreApplication::Run(frameworkViewSource);  
• }  
  

我们亲自来实践运行看效果

识别效果

---

欢迎光临 滴水逆向联盟 (http://www.dtdebug.com/)

Powered by Discuz! X3.2