基于Visual Studio2012实现Windows8的metro界面笔迹手写识别文档

其他 2019-03-08 14:08:01 阅读次数: 0

分享一下我老师大神的人工智能教程吧。零基础！通俗易懂！风趣幽默！还带黄段子！希望你也加入到我们人工智能的队伍中来！http://www.captainbed.net

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

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

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

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

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

详细请见代码分析

#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, ¶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);
}

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

识别效果


 

赶紧下载VS11体验吧

http://www.microsoft.com/click/services/Redirect2.ashx?CR_CC=200098144

再分享一下我老师大神的人工智能教程吧。零基础！通俗易懂！风趣幽默！还带黄段子！希望你也加入到我们人工智能的队伍中来！http://www.captainbed.net

猜你喜欢

转载自www.cnblogs.com/wicnwicnwh/p/10495303.html
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022