精华内容
下载资源
问答
  • D2d通信模拟代码

    2018-03-18 20:44:12
    代码D2d通信全过程,通过代码编写,并在linux下进行全过程的仿真过程,在你已经安装好了ns3各个模板库,通过用该代码来进行仿真,便能很熟悉的完成仿真过程!
  • d2d系统matlab代码自述文件 这组MATLAB代码是CVODES和MATLAB之间的极少链接。 它是在我的博士论文的早期阶段编写的,虽然可能对小型项目有用,但是代码却不是最理想的,而且许多更成熟的软件包更适合在System ...
  • BTS-D2D-Project-MatLab:MWSN中基于能耗的路由协议之间的比较 作者:RubénDiab 目标项目: 移动无线传感器网络(MWSN)中基于能耗的路由协议之间的比较 已实现的路由协议: 直接沟通 浸出 飞马座 梦 实施的渠道和...
  • d2d代码 编译器版本:vs2010 代码有问题,渲染无效,不要下。
  • d2d系统matlab代码Data2Dynamics软件 联系人: Andreas Raue- 引用: Raue A.,等。 生物信息学,31(21),3558-3560,2015。 Raue A.,等。 一号公报,8(9),e74335,2013。 视频:在此了解使用D2D软件进行模型...
  • windows程序设计D2D游戏开发新手学习参考用,自己以前写的一个练手游戏类似魔域实战型的12300行代码,一次传不完其他资源QQ2216908086
  • D2D存储系统中具有不平等修复位置的可修复喷泉代码
  • d2d系统matlab代码欢迎来到lte-sidelink项目页面 lte-sidelink是在MATLAB中由开发的开放式软件库,它实现3GPP LTE侧链接口的功能,包括物理信号,物理信道,传输信道,无线电协议过程和收发器操作。 它适用于D2D和V2...
  • 关于d2d通信的matlab代码无线资源虚拟化与设备到设备通信底层 LTE 网络 在 LTE 网络下通过设备到设备通信实现无线资源虚拟化 • 描述: 无线资源虚拟化是满足日益增长的移动数据服务需求的潜在解决方案。 虚拟化允许...
  • 基于5G D2D的移动边缘计算仿真实验 环境要求 您需要在有Python3环境的电脑上运行本项目代码,并且至少需要安装numpy库。 如果您想运行包括测试内部的代码,您还需要安装jupyter和matplotlib库。 本项目在python ...
  • D2D 的车辆通信的资源分配”,IEEE 通信交易,第一卷。 65,没有。 7,第 3186-3197 页,2017 年 7 月。 请从主文件:“main_rateVsSpeed.m”开始,复制论文中的图5。 所有其他(函数)文件都在主文件中调用。 论文...
  • D2d通信仿真全过程

    2018-03-18 21:14:30
    内附D2d通信仿真全过程,有两种模式,静态D2d仿真和动态D2d仿真,代码为资源的前一个D2d通信模拟代码 ,该仿真过程配套代码
  • d2d系统matlab代码React扩散模拟器 用于模拟类型的React扩散方程的小型工具箱 与扩散矩阵 通过有限差分将空间离散化,并将其转换为一个大型ODE系统,该系统可使用MATLAB的ode15s求解器进行求解。 特征 在一个或两个...
  • 完整的D2GS 1.09d代码,该源代码来自开发人员的网站 关于Diablo2 Close Battle.net服务器 如您所见,我和我的合作伙伴去年制造了一款具有Diablo2关闭游戏支持功能的Battle.net服务器。 我将尝试解释它的工作原理...
  • D2D系统的信道分配

    2019-03-21 00:08:45
    这个代码是一个基于Python的关于d2d信道分配的问题,在蜂窝网络下如何进行信道分配。
  • D2D网络毫米波频段 此MATLAB代码在毫米波波段(@ 28 GHz)的信号干扰加噪声比(SINR)覆盖概率上模拟了PPP无线通信,概率为prob [SINR> T]。 网络元素是基于Poisson点过程(PPP)分布进行分布的。 网络元素是: 1- ...
  • D2D功率控制-Matlab

    2020-03-28 23:53:51
    求大佬给菜鸟讲解基于Matlab的D2D功率控制代码,涉及开环、闭环、联合功率控制。

    求大佬给菜鸟讲解基于Matlab的D2D功率控制代码,涉及开环、闭环、联合功率控制。

    展开全文
  • matlab麦克斯韦评分代码本文的pytorch实现。 介绍 该项目是检测跟踪和跟踪检测的pytorch实现。 该存储库受以下实现的影响: ,基于Pytorch ,基于Pycaffe + Numpy ,基于Pytorch + Numpy ,基于TensorFlow + Numpy ...
  • CF# 368 D2 D

    2016-08-25 22:25:00
    很容易想到可以它操作序列弄成有向图,果断深搜。...看看代码吧 #include <iostream> #include <cstdio> #include <cstring> #include <algorithm> #include <...

    很容易想到可以它操作序列弄成有向图,果断深搜。但我开始竟然用了一种特醇的方法,每个书架做一次深搜,复杂度O(nq),跑到57个test就不动了。看看代码吧

    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <algorithm>
    #include <vector>
    //#include <bitset>
    using namespace std;
    
    const int MAXOPT = 100005;
    
    struct OPT{
    	int opt, r, c;
    }op[MAXOPT];
    
    
    struct bits{
    	char s[125];
    	void init(){
    		for(int i = 0; i < 125; i++) s[i] = 0;
    	}
    	bool find(int k){
    		int p = k / 8;
    		int m = k % 8;
    		if(s[p] & (1<<m)) return true;
    		return false;
    	}
    	
    	void set(int k){
    		int p = k / 8;
    		int m = k % 8;
    		s[p] |= (1<<m);
    	}
    	
    	void reset(int k){
    		int p = k / 8;
    		int m = k % 8;
    		s[p] ^= (1<<m);
    	}
    	
    	void flip(){
    		for(int i = 0; i < 125; i++){
    			s[i] ^= (-1);
    		}
    	}
    };
    
    struct STATE{
    	bits st;
    	void init(){
    		st.init();
    		counts = 0;
    	}
    	int counts;
    };
    
    vector<int>nt[MAXOPT];
    
    int ans[MAXOPT];
    int n, m, q;
    
    
    void dfs(int pos, STATE iter, int sh){
    	int sz = nt[pos].size();
    	for(int k = 0; k < sz; k++){
    		ans[nt[pos][k]] += iter.counts;
    		dfs(nt[pos][k], iter, sh);
    	}
    	
    	while(op[pos + 1].opt != 4 && pos < q){
    		pos ++;
    		if(op[pos].r == sh){
    			if(op[pos].opt == 1){
    				if(!iter.st.find(op[pos].c - 1)){
    					iter.counts++;
    					iter.st.set(op[pos].c - 1);
    				}
    			}
    			else if(op[pos].opt == 2){
    				if(iter.st.find(op[pos].c - 1)){
    					iter.counts --;
    					iter.st.reset(op[pos].c - 1);
    				}
    			}
    			else {
    				iter.st.flip();
    				iter.counts = m - iter.counts;
    			}
    		}
    		ans[pos] += iter.counts;
    		int sz = nt[pos].size();
    		for(int k = 0; k < sz; k++){
    			ans[nt[pos][k]] += iter.counts;
    			dfs(nt[pos][k], iter, sh);
    		}
    	}
    	
    }
    
    int main(){
    	int opt, r, c;
    	memset(ans, 0, sizeof(ans));
    	scanf("%d%d%d", &n, &m, &q);
    	for(int i = 0; i <= q; i++)
    		nt[i].clear();
    	
    	for(int i = 1; i <= q; i++){
    		scanf("%d", &op[i].opt);
    		if(op[i].opt == 1 || op[i].opt == 2){
    			scanf("%d%d", &op[i].r, &op[i].c);
    		}
    		else {
    			scanf("%d", &op[i].r);
    		}
    		if(op[i].opt == 4){
    			nt[op[i].r].push_back(i);
    		}
    	}
    	for(int i = 1; i <= n; i++){
    		STATE iter;
    		iter.init();
    		ans[0] += iter.counts;
    		dfs(0, iter, i);
    	}
    	
    	for(int i = 1; i <= q; i++){
    		printf("%d\n", ans[i]);
    	}
    	
    	return 0;
    }
    

      

     

    后来想到,一次操作只动一个书架,深搜之后把原来的状态还原回去就可以啦,复杂度O(q)。

    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <algorithm>
    #include <vector>
    //#include <bitset>
    using namespace std;
    
    const int MAXOPT = 100005;
    
    int state[1005][1005];
    
    int n, m, q;
    
    struct operation{
    	int op, r, c;
    }op[MAXOPT];
    int ans[MAXOPT];
    vector<int> nt[MAXOPT];
    
    
    void dfs(int u){
    	int sz = nt[u].size();
    	for(int i = 0; i < sz; i++){
    		int v = nt[u][i];
    		if(op[v].op == 1){
    			int pre = state[op[v].r][op[v].c];
    			if(!pre){
    				state[op[v].r][op[v].c] = 1;
    				ans[v] = ans[u] + 1;
    			}
    			else ans[v] = ans[u];
    			dfs(v);
    			state[op[v].r][op[v].c] = pre;
    		}
    		else if(op[v].op == 2){
    			int pre = state[op[v].r][op[v].c];
    			if(pre){
    				state[op[v].r][op[v].c] = 0;
    				ans[v] = ans[u] - 1;
    			}
    			else ans[v] = ans[u];
    			dfs(v);
    			state[op[v].r][op[v].c] = pre;
    		}
    		else if(op[v].op == 3){
    			int c = 0;
    			for(int k = 1; k <=m; k++){
    				if(state[op[v].r][k]) c++;
    				state[op[v].r][k] ^= 1;
    			}
    			ans[v] = ans[u] - c + m - c;
    			dfs(v);
    			
    			for(int k = 1; k <=m; k++){
    				state[op[v].r][k] ^= 1;
    			}
    			
    		}
    		else{
    			ans[v] = ans[u];
    			dfs(v);
    		}
    	}
    }
    
    
    int main(){
    	
    	scanf("%d%d%d", &n, &m, &q);
    	memset(ans, 0, sizeof(ans));
    	memset(state, 0, sizeof(state));
    	for(int i = 1; i <= q; i++){
    		scanf("%d", &op[i].op);
    		if(op[i].op == 1 || op[i].op == 2){
    			scanf("%d%d", &op[i].r, &op[i].c);
    		}
    		else{
    			scanf("%d", &op[i].r);
    		}
    		if(op[i].op == 4) nt[op[i].r].push_back(i);
    		else nt[i - 1].push_back(i);
    	}
    	
    	dfs(0);
    	
    	for(int i = 1; i <= q; i++)
    		printf("%d\n", ans[i]);
    	
    	return 0;
    }
    

      

    转载于:https://www.cnblogs.com/jie-dcai/p/5808598.html

    展开全文
  • D2D引擎与GDI\GDI+绘制效果对比

    万次阅读 2015-02-02 18:12:38
    本例主要是对比D2D和GDI在绘制文字、线条的区别,以及D2D与GDI+在绘制图片时的区别。 D2D是基于COM组件开发的,使用前的CoInitialize(NULL)是必须的;另外,GDI+的初始化GdiplusStartup()也别忘了。 废话少说,...

    本例主要是对比D2D和GDI在绘制文字、线条的区别,以及D2D与GDI+在绘制图片时的区别。

    D2D是基于COM组件开发的,使用前的CoInitialize(NULL)是必须的;另外,GDI+的初始化GdiplusStartup()也别忘了。

    废话少说,完整代码如下:

    // D2DDemo.cpp : 定义应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include "D2DDemo.h"
    #include <D2D1.h>
    #include <DWrite.h>
    #pragma comment(lib, "D2D1")
    #pragma comment(lib, "DWrite")
    #include <atlbase.h>
    #include <atlcom.h>
    #include <wincodec.h>
    #pragma comment(lib, "windowscodecs")
    #include <GdiPlus.h>
    #pragma comment(lib, "GdiPlus")
    using namespace Gdiplus;
    
    
    #define MAX_LOADSTRING 100
    // 全局变量:
    HINSTANCE hInst;								// 当前实例
    TCHAR szTitle[MAX_LOADSTRING];					// 标题栏文本
    TCHAR szWindowClass[MAX_LOADSTRING];			// 主窗口类名
    
    // 此代码模块中包含的函数的前向声明:
    ATOM				MyRegisterClass(HINSTANCE hInstance);
    BOOL				InitInstance(HINSTANCE, int);
    LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
    INT_PTR CALLBACK	About(HWND, UINT, WPARAM, LPARAM);
    BOOL				InitD2DResource();
    BOOL				InitDeviceResource(HWND hWnd);
    void				D2DDraw();
    BOOL				OnCreate(HWND hWnd);
    HRESULT				LoadBitmapFromFile(
    						   ID2D1RenderTarget *pRenderTarget,
    						   IWICImagingFactory *pIWICFactory,
    						   PCWSTR uri,
    						   UINT destinationWidth,
    						   UINT destinationHeight,
    						   ID2D1Bitmap **ppBitmap
    						   );
    //这里来定义全局变量
    CComPtr<ID2D1Factory>			g_pD2d1Factory;
    CComPtr<IDWriteFactory>			g_pDWriteFactory;
    CComPtr<IDWriteTextFormat>		g_pDWriteFormat;
    CComPtr<ID2D1HwndRenderTarget>	g_pD2D1HwndRender;
    CComPtr<ID2D1GdiInteropRenderTarget>	g_pD2DGdiRender;
    CComPtr<IWICImagingFactory>		g_pWicImageFactory;
    CComPtr<ID2D1Bitmap>			g_pBkImage;
    LOGFONT g_logFont;
    HFONT	g_hTextFont	= NULL;
    #define FREE_COM_PTR(x)	{ if (x) { x->Release(); x = NULL; } }
    
    int APIENTRY _tWinMain(HINSTANCE hInstance,
                         HINSTANCE hPrevInstance,
                         LPTSTR    lpCmdLine,
                         int       nCmdShow)
    {
    	UNREFERENCED_PARAMETER(hPrevInstance);
    	UNREFERENCED_PARAMETER(lpCmdLine);
    	HRESULT hr = CoInitialize(NULL);
    	ULONG_PTR ptr;
    	GdiplusStartupInput	input;
    	GdiplusStartup(&ptr, &input, NULL);
     	// TODO: 在此放置代码。
    	MSG msg;
    	HACCEL hAccelTable;
    	memset(&g_logFont, 0, sizeof(LOGFONT));
    	g_logFont.lfHeight	= 40;
    	g_logFont.lfWidth	= 0;
    	g_logFont.lfWeight	= FW_NORMAL;
    	g_logFont.lfCharSet	= DEFAULT_CHARSET;
    	g_logFont.lfOutPrecision	= OUT_DEFAULT_PRECIS;
    	g_logFont.lfClipPrecision	= CLIP_DEFAULT_PRECIS;
    	g_logFont.lfQuality			= DEFAULT_QUALITY;
    	g_logFont.lfPitchAndFamily	= DEFAULT_PITCH|FF_SWISS;
    	wcscpy(g_logFont.lfFaceName, L"微软雅黑");
    	g_hTextFont = CreateFontIndirect(&g_logFont);
    	// 初始化全局字符串
    	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    	LoadString(hInstance, IDC_D2DDEMO, szWindowClass, MAX_LOADSTRING);
    	MyRegisterClass(hInstance);
    
    	// 执行应用程序初始化:
    	if (!InitInstance (hInstance, nCmdShow))
    	{
    		return FALSE;
    	}
    
    	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_D2DDEMO));
    
    	// 主消息循环:
    	while (GetMessage(&msg, NULL, 0, 0))
    	{
    		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
    		{
    			TranslateMessage(&msg);
    			DispatchMessage(&msg);
    		}
    	}
    	if ( g_hTextFont )
    	{
    		DeleteObject(g_hTextFont);
    		g_hTextFont = NULL;
    	}
    	GdiplusShutdown(ptr);
    	CoUninitialize();
    	return (int) msg.wParam;
    }
    
    
    
    //
    //  函数: MyRegisterClass()
    //
    //  目的: 注册窗口类。
    //
    //  注释:
    //
    //    仅当希望
    //    此代码与添加到 Windows 95 中的“RegisterClassEx”
    //    函数之前的 Win32 系统兼容时,才需要此函数及其用法。调用此函数十分重要,
    //    这样应用程序就可以获得关联的
    //    “格式正确的”小图标。
    //
    ATOM MyRegisterClass(HINSTANCE hInstance)
    {
    	WNDCLASSEX wcex;
    
    	wcex.cbSize = sizeof(WNDCLASSEX);
    
    	wcex.style			= CS_HREDRAW | CS_VREDRAW;
    	wcex.lpfnWndProc	= WndProc;
    	wcex.cbClsExtra		= 0;
    	wcex.cbWndExtra		= 0;
    	wcex.hInstance		= hInstance;
    	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_D2DDEMO));
    	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
    	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
    	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_D2DDEMO);
    	wcex.lpszClassName	= szWindowClass;
    	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
    
    	return RegisterClassEx(&wcex);
    }
    
    //
    //   函数: InitInstance(HINSTANCE, int)
    //
    //   目的: 保存实例句柄并创建主窗口
    //
    //   注释:
    //
    //        在此函数中,我们在全局变量中保存实例句柄并
    //        创建和显示主程序窗口。
    //
    BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
    {
       HWND hWnd;
    
       hInst = hInstance; // 将实例句柄存储在全局变量中
    
       hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
          CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
    
       if (!hWnd)
       {
          return FALSE;
       }
    
       ShowWindow(hWnd, nCmdShow);
       UpdateWindow(hWnd);
    
       return TRUE;
    }
    
    //
    //  函数: WndProc(HWND, UINT, WPARAM, LPARAM)
    //
    //  目的: 处理主窗口的消息。
    //
    //  WM_COMMAND	- 处理应用程序菜单
    //  WM_PAINT	- 绘制主窗口
    //  WM_DESTROY	- 发送退出消息并返回
    //
    //
    LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    {
    	int wmId, wmEvent;
    	PAINTSTRUCT ps;
    	HDC hdc;
    
    	switch (message)
    	{
    	case WM_COMMAND:
    		wmId    = LOWORD(wParam);
    		wmEvent = HIWORD(wParam);
    		// 分析菜单选择:
    		switch (wmId)
    		{
    		case IDM_ABOUT:
    			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
    			break;
    		case IDM_EXIT:
    			DestroyWindow(hWnd);
    			break;
    		default:
    			return DefWindowProc(hWnd, message, wParam, lParam);
    		}
    		break;
    	case WM_CREATE:
    		OnCreate(hWnd);
    		break;
    	case WM_PAINT:
    		hdc = BeginPaint(hWnd, &ps);
    		// TODO: 在此添加任意绘图代码...
    		D2DDraw();
    		EndPaint(hWnd, &ps);
    		break;
    	case WM_DESTROY:
    		PostQuitMessage(0);
    		break;
    	case WM_SIZE:
    		{
    			if ( g_pD2D1HwndRender )
    			{
    				int nWidth = LOWORD(lParam);
    				int nHeight= HIWORD(lParam);
    				D2D1_SIZE_U sz = D2D1::SizeU(nWidth, nHeight);
    				g_pD2D1HwndRender->Resize(sz);
    			}
    		}
    	case WM_ERASEBKGND:
    		return TRUE;
    	default:
    		return DefWindowProc(hWnd, message, wParam, lParam);
    	}
    	return 0;
    }
    
    // “关于”框的消息处理程序。
    INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
    {
    	UNREFERENCED_PARAMETER(lParam);
    	switch (message)
    	{
    	case WM_INITDIALOG:
    		return (INT_PTR)TRUE;
    
    	case WM_COMMAND:
    		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
    		{
    			EndDialog(hDlg, LOWORD(wParam));
    			return (INT_PTR)TRUE;
    		}
    		break;
    	}
    	return (INT_PTR)FALSE;
    }
    
    BOOL InitD2DResource()
    {
    	BOOL bRet = FALSE;
    	ID2D1Factory*			pD2dFactory			= NULL;
    	IDWriteFactory*			pDwriteFactory		= NULL;
    	IDWriteTextFormat*		pDwriteTextFormat	= NULL;
    	IWICImagingFactory*		pWicImgFactory		= NULL;
    	try
    	{
    		HRESULT hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &pD2dFactory);
    		if ( FAILED(hr) )
    			throw L"D2D1CreateFactory error!";
    		hr = CoCreateInstance( CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
    			IID_IWICImagingFactory, (LPVOID*)&pWicImgFactory );
    		if ( FAILED(hr) )
    			throw L"CoCreateInstance error!";
    		hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), \
    			reinterpret_cast<IUnknown**>(&pDwriteFactory));
    		if ( FAILED(hr) )
    			throw L"DWriteCreateFactory error!";
    		hr = pDwriteFactory->CreateTextFormat(L"微软雅黑", NULL, DWRITE_FONT_WEIGHT_REGULAR, \
    			DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, 30.0f, L"chs", &pDwriteTextFormat);
    		if ( FAILED(hr) )
    			throw L"CreateTextFormat error!";
    		//水平居中
    		pDwriteTextFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);
    		//垂直居中
    		pDwriteTextFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_CENTER);
    		bRet = TRUE;
    	}
    	catch(WCHAR* pMsg)
    	{
    		MessageBox(NULL, pMsg, L"InitD2DResource出错:", IDOK);
    	}
    	catch(...)
    	{
    
    	}
    	if ( bRet )
    	{
    		g_pD2d1Factory		= pD2dFactory;
    		g_pDWriteFactory	= pDwriteFactory;
    		g_pDWriteFormat		= pDwriteTextFormat;
    		g_pWicImageFactory	= pWicImgFactory;
    	}
    	else
    	{
    		FREE_COM_PTR(pD2dFactory);
    		FREE_COM_PTR(pDwriteFactory);
    		FREE_COM_PTR(pDwriteTextFormat);
    		FREE_COM_PTR(pWicImgFactory);
    	}
    	return bRet;
    }
    
    
    BOOL InitDeviceResource(HWND hWnd)
    {
    	if ( g_pD2d1Factory == NULL )
    		return FALSE;
    	RECT rc;
    	GetClientRect(hWnd, &rc);
    	D2D1_SIZE_U sz = D2D1::SizeU(rc.right-rc.left, rc.bottom-rc.top);
    	D2D1_RENDER_TARGET_PROPERTIES rtProps = D2D1::RenderTargetProperties();
    	rtProps.usage =  D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE;
    	HRESULT hr = g_pD2d1Factory->CreateHwndRenderTarget( rtProps, \
    		D2D1::HwndRenderTargetProperties(hWnd, sz), &g_pD2D1HwndRender);
    	if ( FAILED(hr) )
    		return FALSE;
    	hr = g_pD2D1HwndRender->QueryInterface(__uuidof(ID2D1GdiInteropRenderTarget), (void**)&g_pD2DGdiRender);
    	return SUCCEEDED(hr);
    }
    
    void D2DDraw()
    {//D2D GDI混合绘图
    	if ( g_pD2D1HwndRender == NULL )
    		return ;
    	g_pD2D1HwndRender->BeginDraw();
    	//D2D绘制
    	g_pD2D1HwndRender->Clear(D2D1::ColorF(RGB(255,255,255), 1.0));
    	//绘制背景位图
    	if ( g_pBkImage )
    	{
    		D2D1_RECT_F desRc = D2D1::RectF(420.0f, 0.0f, 720.0f, 200.0f);
    		g_pD2D1HwndRender->DrawBitmap(g_pBkImage, &desRc);
    	}
    	const WCHAR* pText = L"Hello world!!! by D2D";
    	D2D1_RECT_F rc = D2D1::RectF(0,0,400,100);
    	CComPtr<ID2D1SolidColorBrush> pTextBrush;
    	g_pD2D1HwndRender->CreateSolidColorBrush(D2D1::ColorF(RGB(155,0,255), 2.0), &pTextBrush);
    	CComPtr<ID2D1SolidColorBrush> pLineBrush;
    	g_pD2D1HwndRender->CreateSolidColorBrush(D2D1::ColorF(RGB(0,0,255), 1.0), &pLineBrush);
    	g_pD2D1HwndRender->DrawLine(D2D1::Point2F(0.0f, 0.0f), D2D1::Point2F(400.0F, 100.0F), pLineBrush, 1.0);
    	g_pD2D1HwndRender->DrawText(pText, wcslen(pText), g_pDWriteFormat, rc, pTextBrush);
    	//GDI绘制
    	if ( g_pD2DGdiRender == NULL )
    	{
    		g_pD2D1HwndRender->EndDraw();
    		return ;
    	}
    	HDC hDC = NULL;
    	HRESULT hr = g_pD2DGdiRender->GetDC(D2D1_DC_INITIALIZE_MODE_COPY, &hDC);
    	if ( SUCCEEDED(hr) )
    	{
    		{
    			Graphics g(hDC);
    			Image image(L"1.jpg");
    			g.DrawImage(&image, 420, 220, 300, 200);
    		}
    		//绘制文字
    		HFONT hOldFont = (HFONT)SelectObject(hDC, g_hTextFont);
    		SetTextColor(hDC, RGB(255,0,155));
    		SetBkMode(hDC, TRANSPARENT);
    		RECT rcText = {0,100,400,200};
    		pText = L"Hello world!!! by GDI";
    		DrawText(hDC, pText, wcslen(pText), &rcText, DT_CENTER|DT_VCENTER|DT_SINGLELINE);
    		SelectObject(hDC, hOldFont);
    		//绘制线条
    		HPEN hPen = CreatePen(PS_SOLID, 2, RGB(255,0,0));
    		HPEN hOldPen = (HPEN)SelectObject(hDC, hPen);
    		POINT pt;
    		MoveToEx(hDC, 0, 100, &pt);
    		LineTo(hDC, 400, 200);
    		SelectObject(hDC, hOldPen);
    		DeleteObject(hPen);
    		g_pD2DGdiRender->ReleaseDC(NULL);
    	}
    	g_pD2D1HwndRender->EndDraw();
    }
    
    BOOL OnCreate( HWND hWnd )
    {
    	if ( !InitD2DResource() )
    		goto __error;
    	if ( !InitDeviceResource(hWnd) )
    		goto __error;
    	ID2D1Bitmap* pBitmap = NULL;
    	HRESULT hr = LoadBitmapFromFile(g_pD2D1HwndRender, g_pWicImageFactory, L"1.jpg", 0, 500, &pBitmap);
    	if ( SUCCEEDED(hr) )
    	{
    		g_pBkImage = pBitmap;
    	}
    	goto __successed;
    __error:
    	PostQuitMessage(0);
    	return FALSE;
    __successed:
    	return TRUE;
    }
    
    HRESULT LoadBitmapFromFile(
    						   ID2D1RenderTarget *pRenderTarget,
    						   IWICImagingFactory *pIWICFactory,
    						   PCWSTR uri,
    						   UINT destinationWidth,
    						   UINT destinationHeight,
    						   ID2D1Bitmap **ppBitmap
    						   )
    {
    	HRESULT hr = S_OK;
    
    	CComPtr<IWICBitmapDecoder>		pDecoder = NULL;
    	CComPtr<IWICBitmapFrameDecode>	pSource = NULL;
    	CComPtr<IWICStream>				pStream = NULL;
    	CComPtr<IWICFormatConverter>	pConverter = NULL;
    	CComPtr<IWICBitmapScaler>		pScaler = NULL;
    
    	hr = pIWICFactory->CreateDecoderFromFilename(
    		uri,
    		NULL,
    		GENERIC_READ,
    		WICDecodeMetadataCacheOnLoad,
    		&pDecoder
    		);
    	if ( FAILED(hr) )
    		return hr;
    	// Create the initial frame.
    	hr = pDecoder->GetFrame(0, &pSource);
    	if ( FAILED(hr) )
    		return hr;
    	hr = pIWICFactory->CreateFormatConverter(&pConverter);
    	if ( FAILED(hr) )
    		return hr;
    	// If a new width or height was specified, create an
    	// IWICBitmapScaler and use it to resize the image.
    	if (destinationWidth == 0 && destinationHeight == 0)
    		return S_FALSE;
    	UINT originalWidth, originalHeight;
    	hr = pSource->GetSize(&originalWidth, &originalHeight);
    	if ( FAILED(hr) )
    		return hr;
    	if (destinationWidth == 0)
    	{
    		FLOAT scalar = static_cast<FLOAT>(destinationHeight) / static_cast<FLOAT>(originalHeight);
    		destinationWidth = static_cast<UINT>(scalar * static_cast<FLOAT>(originalWidth));
    	}
    	else if (destinationHeight == 0)
    	{
    		FLOAT scalar = static_cast<FLOAT>(destinationWidth) / static_cast<FLOAT>(originalWidth);
    		destinationHeight = static_cast<UINT>(scalar * static_cast<FLOAT>(originalHeight));
    	}
    	hr = pIWICFactory->CreateBitmapScaler(&pScaler);
    	if ( FAILED(hr) )
    		return hr;
    	hr = pScaler->Initialize(
    		pSource,
    		destinationWidth,
    		destinationHeight,
    		WICBitmapInterpolationModeCubic
    		);
    	if ( FAILED(hr) )
    		return hr;
    	hr = pConverter->Initialize( pScaler, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone,
    		NULL, 0.f, WICBitmapPaletteTypeMedianCut );
    	if ( FAILED(hr) )
    		return hr;
    	// Create a Direct2D bitmap from the WIC bitmap.
    	hr = pRenderTarget->CreateBitmapFromWicBitmap( pConverter, NULL, ppBitmap );
    	return hr;
    }
    
    基于COM的对象在使用完之后都应该调用Release(),当引用计数为0时,将删除这个对象。这里为了使用方便,用到了COM里的智能指针CComPtr,析构时会自动调用对象的Release方法,可以查看ATL源码。

    运行图如下:


    对比效果可以明显发现,D2D绘制文字、线条(实际上调用的是DirectWrite)效果好于GDI,GDI的锯齿太明显了。在绘图方面,感觉D2D和GDI+的绘制效果差不多。但是,GDI+的性能大家都知道那叫一个渣,而且不支持硬件加速。

    展开全文
  • D2H9、BGK、omega = 1,用作基准的 2D 通道中的层流。 需要图像处理工具箱。 代码既没有针对内存也没有针对速度进行优化,即根本没有效率。 但是,它总比没有好(即 2005 年 2 月的当前 MATLAB 情况?据我所知) ...
  • Drupal - 如何使用 Migrate 和 Migrate_d2d 将内容从 drupal 6 迁移到 7 使用 Migrate 和 Drupal 到 Drupal 数据迁移模块将内容从 Drupal 6 迁移到 7 的的中使用的代码
  • matlab终止以下代码GLNS GLNS是在Julia()中实现的广义旅行商问题(GTSP)的求解器。 有关求解器的更多信息,请参见 引用这项工作 GLNS求解器及其设置在以下论文中进行了描述: @Article{Smith2017GLNS, author = ...
  • matlab终止以下代码GLNS GLNS是在Julia()中实现的广义旅行商问题(GTSP)的求解器。 有关求解器的更多信息,请参见 引用这项工作 GLNS求解器及其设置在以下论文中进行了描述: @Article{Smith2017GLNS, author = ...
  • 已嵌入物理引擎代码 。 已嵌入脚本操作系统代码 。 脚本操作系统 简介:语言为简化C语言,自制编译器(词法+语法+ LR分析),IR(基于寄存器),虚拟机,GUI,VFS 原理:执行程序时,即时编译代码并执行所生成的二...
  • 第一个D2D程序运行及配置

    千次阅读 2017-01-29 14:51:53
    1.为啥要加头文件和库文件? .h头文件只是函数的声明。 .lib才是函数实现的地方。 只不过,如果你加载的是系统头文件,默认会帮你加上.lib...但是别人一般不会把源代码一块给你,只给你一个.lib文件 你可以把.lib文件理

    1.为啥要加头文件和库文件?

    .h头文件只是函数的声明。

    .lib才是函数实现的地方。

    只不过,如果你加载的是系统头文件,默认会帮你加上.lib文件。
    如果如时是你自己写的函数,就要手动添加.lib文件了
    dll是动态链接,lib是静态链接。
    你自己写的函数一般都包括.h头文件,.cpp实现文件。
    但是别人一般不会把源代码一块给你,只给你一个.lib文件
    你可以把.lib文件理解成编译好的.cpp文件。

    先来阐述一下DLL(Dynamic Linkable Library)的概念,你可以简单的把DLL看成一种仓库,它提供给你一些可以直接拿来用的变量、函数或类。

    静态链接库与动态链接库都是共享代码的方式,如果采用静态链接库,则无论你愿不愿意,lib中的指令都被直接包含在最终生成的EXE文件中了。但是若使用DLL,该DLL不必被包含在最终的EXE文件中,EXE文件执行时可以“动态”地引用和卸载这个与EXE独立的DLL文件。

    采用动态链接库的优点:(1)更加节省内存;(2)DLL文件与EXE文件独立,只要输出接口不变,更换DLL文件不会对EXE文件造成任何影响,因而极大地提高了可维护性和可扩展性。

    动态链接是相对于静态链接而言的。所谓静态链接是指把要调用的函数或者过程链接到可执行文件中,成为可执行文件的一部分。换句话说,函数和过程的代码就在程序的EXE文件中,该文件包含了运行时所需的全部代码。当多个程序都调用相同函数时,内存中就会存在这个函数的多个拷贝,这样就浪费了宝贵的内存资源。而动态链接所调用的函数代码并没有被拷贝到应用程序的可执行文件中去,而是仅仅在其中加入了所调用函数的描述信息(往往是一些重定位信息)。仅当应用程序被装入内存开始运行时,在Windows的管理下,才在应用程序与相应的DLL之间建立链接关系。当要执行所调用DLL中的函数时,根据链接产生的重定位信息,Windows才转去执行DLL中相应的函数代码。
    静态链接的执行程序能够在其它同类操作系统的机器上直接运行,比如一个EXE文件是在WIN2000系统上静态链接的,那么将该文件直接拷贝到另一台WIN2000的机器上,是可以运行的。
    而动态链接的执行程序则不可以,除非把该EXE文件所需的DLL文件都一并拷贝过去,或者对方机器上也有所需的相同版本的DLL文件,否则是不能保证正常运行的。
    不过静态链接得到的文件比较大,而动态链接得到的文件比较小。

    2.怎么配置头文件和库文件?


    怎么一次修改配置,而不是每次新建程序修改?


    视图-》其他窗口-》属性管理器->点那个项目->点Debug|Win32->点Microsoft.Cpp.Win32.user


    在VC++目录里-》包含目录里,加入include路径里的头文件
    在VC+=目录里的库目录里加入lib文件夹路径
    在链接器 的输入里加入d2d1.lib

    3.新建一个D2D程序

    接下来在VS中创建一个win32项目(注意不要建错),要建立空项目,此处一个样例代码是建立一个sin移动的矩形
    1. /*************************************************************** 
    2. 功能:简单的D2D窗口创建、矩形的sin曲线移动 
    3. 作者:*** 
    4. 版本:1.0 
    5. 日期:2016.4 
    6. ****************************************************************/  
    7. #include <Windows.h>  
    8. #include<d2d1.h>  
    9. #include<cmath>  
    10.   
    11. //函数声明  
    12. void CreateResource();  
    13.   
    14. //变量声明  
    15. ID2D1Factory *pFactory = NULL;  
    16. ID2D1HwndRenderTarget *pRenderTarget = NULL;  
    17. ID2D1SolidColorBrush *pBrush = NULL;  
    18.   
    19. HWND hwnd = 0;  
    20. RECT rt = { 0 }, rtClient = { 0 };  
    21. int num = 1;  
    22.   
    23. void init()  
    24. {  
    25.     if (!hwnd)  
    26.     {  
    27.         return;  
    28.     }  
    29.     GetClientRect(hwnd, &rtClient);  
    30.     CreateResource();  
    31. }  
    32.   
    33. void CreateResource()  
    34. {  
    35.     HRESULT hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &pFactory);  
    36.     if (SUCCEEDED(hr))  
    37.     {  
    38.         hr = pFactory->CreateHwndRenderTarget(  
    39.             D2D1::RenderTargetProperties(),  
    40.             D2D1::HwndRenderTargetProperties(  
    41.             hwnd,  
    42.             D2D1::SizeU(  
    43.             rtClient.right - rtClient.left,  
    44.             rtClient.bottom - rtClient.top)),  
    45.             &pRenderTarget);  
    46.         if (SUCCEEDED(hr))  
    47.         {  
    48.             hr = pRenderTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Red), &pBrush);  
    49.             if (FAILED(hr))  
    50.             {  
    51.                 MessageBox(hwnd, TEXT("Create Resource Fail!"), TEXT("Error"), MB_OK);  
    52.                 return;  
    53.             }  
    54.         }  
    55.     }  
    56. }  
    57. void DrawRectangle()  
    58. {  
    59.     if (pRenderTarget){  
    60.         pRenderTarget->BeginDraw();  
    61.         pRenderTarget->Clear(D2D1::ColorF(D2D1::ColorF::Black));  
    62.         pRenderTarget->DrawRectangle(D2D1::RectF(rt.left + 0.0f, rt.top + 200.0f, rt.right + 50.0f, rt.bottom + 250.0f), pBrush);  
    63.         pRenderTarget->EndDraw();  
    64.     }  
    65. }  
    66. void Render()  
    67. {  
    68.     DrawRectangle();  
    69.     num += 5;  
    70.     rt.right += 2;  
    71.     rt.left += 2;  
    72.     rt.top = (100 * sin(num * 3.14 / 180));  
    73.     rt.bottom = (100 * sin(num * 3.14 / 180));  
    74.     if (rt.right == 1000)  
    75.     {  
    76.         rt = { 0 };  //这句有点问题去掉仍可正常运行
    77.         num = 0;  
    78.     }  
    79. }  
    80.   
    81. template<class Interface>  
    82. inline void SafeRelease(Interface **ppinterfaceToRelease)  
    83. {  
    84.     if (NULL != *ppinterfaceToRelease)  
    85.     {  
    86.         (*ppinterfaceToRelease)->Release();  
    87.         (*ppinterfaceToRelease) = NULL;  
    88.     }  
    89. }  
    90. void CleanUp()  
    91. {  
    92.     SafeRelease(&pBrush);  
    93.     SafeRelease(&pRenderTarget);  
    94.     SafeRelease(&pFactory);  
    95. }  
    96.   
    97. LRESULT CALLBACK WndProc(HWND Hwnd, UINT message, WPARAM wParam, LPARAM iParam);  
    98. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInst, LPSTR lpszCmdLine, int nCmdShow)  
    99. {  
    100.     MSG Msg;  
    101.     WNDCLASS wndclass;  
    102.     TCHAR lpszTitle[] = TEXT("MyDemo001");  
    103.   
    104.     wndclass.style = CS_HREDRAW|CS_VREDRAW;  
    105.     wndclass.lpfnWndProc = WndProc;  
    106.     wndclass.cbClsExtra = 0;  
    107.     wndclass.cbWndExtra = 0;  
    108.     wndclass.hInstance = hInstance;  
    109.     wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);  
    110.     wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);  
    111.     wndclass.lpszMenuName = NULL;  
    112.     wndclass.lpszClassName = TEXT("MyClass");  
    113.     wndclass.hbrBackground = 0;  
    114.     if (!RegisterClass(&wndclass))  
    115.     {  
    116.         MessageBox(NULL, TEXT("RegisterClass fail!"), TEXT("error"), MB_ICONERROR);  
    117.         return 0;  
    118.     }  
    119.   
    120.     hwnd = CreateWindow(  
    121.         TEXT("MyClass"),  
    122.         lpszTitle,  
    123.         WS_OVERLAPPEDWINDOW,  
    124.         CW_USEDEFAULT,  
    125.         CW_USEDEFAULT,  
    126.         CW_USEDEFAULT,  
    127.         CW_USEDEFAULT,  
    128.         NULL,  
    129.         NULL,  
    130.         hInstance,  
    131.         NULL);  
    132.     ShowWindow(hwnd, nCmdShow);  
    133.     UpdateWindow(hwnd);  
    134.     init();  
    135.   
    136.     BOOL bRet;  
    137.     PeekMessage(&Msg, NULL, 0, 0, PM_NOREMOVE);  
    138.     while (Msg.message != WM_QUIT)  
    139.     {  
    140.         bRet = PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE);  
    141.         if (bRet)  
    142.         {  
    143.             TranslateMessage(&Msg);  
    144.             DispatchMessage(&Msg);  
    145.         }  
    146.         else  
    147.         {  
    148.             Render();  
    149.         }  
    150.     }  
    151.     CleanUp();  
    152.     return Msg.wParam;  
    153. }  
    154.   
    155. LRESULT CALLBACK WndProc(HWND Hwnd, UINT message, WPARAM wParam, LPARAM iParam)  
    156. {  
    157.     switch (message)  
    158.     {  
    159.     case WM_DESTROY:  
    160.         PostQuitMessage(0);  
    161.         return 0;  
    162.     }  
    163.     return DefWindowProc(Hwnd, message, wParam, iParam);  
    164. }  

    展开全文
  • Directx9 2d游戏源码. 考虑到大小,所以图片没有一起打包. 里面包括了(资源打包,地图编辑器,游戏主界面). 项目写了一点点就中途弃坑了. 我也是菜鸟,代码不是很美观且很乱. 仅仅适合新手.
  • Depth在kinect中经常被翻译为深度图,指的是图像到摄像头的距离,这些距离数据能让机器知道物理距离有多远。...代码结构:主要的代码是DepthBasic.cpp,这个代码实现了深度图的读取另外一个主要的代
  • Depth在kinect中经常被翻译为深度图,指的是图像到摄像头的距离,这些距离数据能让机器知道物理距离有多远。kinect通过两个红外摄像头来实现这个功能的...下面我们来研究下这个例子的代码,让我们对kinect for wind...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 882
精华内容 352
关键字:

d2d代码