对不同数据类型拼接成一个内存块的封装

最新推荐文章于 2025-09-12 13:20:46 发布
原创 最新推荐文章于 2025-09-12 13:20:46 发布 · 1.5k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

NSDataParser 是一个独立模块，用于管理多种数据类型并转换为连续内存数据块。支持添加和读取各种基本数据类型及字符串等复杂类型，并提供数据大小获取等功能。
部署运行你感兴趣的模型镜像 
/*================================================================*
// NSDataParser.h: interface for the CNSDataParser class.
【头文件】:	NSDataParser.h
【功  能】:	该模块属于独立模块，主要完成管理各种类型数据，
			转换成一个连续的内存数据块。返回的连续数据块为LPVOID类型，
			通过GetData()函数获取到该数据块的地址，通过GetDataSize()
			返回数据块的大小
【注  意】:	
*================================================================*/
#if !defined(AFX_DATAPARSER_H__C18BF820_ED69_42B0_A8F9_9570387F753C__INCLUDED_)
#define AFX_DATAPARSER_H__C18BF820_ED69_42B0_A8F9_9570387F753C__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <afxtempl.h>
//=========================================================================
//=========================================================================
class  CDataParser
{
public:
	CDataParser();
	virtual ~CDataParser();
public:
	// 将数据写入内存
	/*================================================================*
	【函數】:	Add(...)
	【功能】:	往内存中添加各种数据，数据内存所占的长度会根据所加入的
				数据类型动态增加
	【参数】:	
	【返回】:	
	【例子】:	
	【注意】:	当参数为CNSVarObj类型时，往内存中加的是变量的工程值，
				即pVar->GetVarData(),并不是把变量对象中所有数据全加入内存
	*================================================================*/
	virtual BOOL Add(COleVariant* pvData);
	virtual BOOL Add(WORD wData);
	virtual BOOL Add(DWORD wData);
	virtual BOOL Add(LPVOID pData,int iLen);
	virtual BOOL Add(BOOL wData);
	virtual BOOL Add(BYTE wData);
	virtual BOOL Add(char wData);
	virtual BOOL Add(short wData);
	virtual BOOL Add(long wData);
	virtual BOOL Add(float wData);
	virtual BOOL Add(double wData);
	virtual BOOL Add(const COleDateTime& wData);
	virtual BOOL Add(const CString& strData);
public:
	// 从内存中读取值,注：先调用InitData初始化内存数据然后再调用GetData
	virtual void InitData( void *pData,unsigned long nDataSize);
	virtual BOOL GetData(COleVariant& pvData);
	virtual BOOL GetData(WORD &wData);
	virtual BOOL GetData(DWORD &wData);
	virtual BOOL GetData(LPVOID pData);
	virtual BOOL GetData(BOOL &wData);
	virtual BOOL GetData(BYTE &wData);
	virtual BOOL GetData(char &wData);
	virtual BOOL GetData(short &wData);
	virtual BOOL GetData(long &wData);
	virtual BOOL GetData(float &wData);
	virtual BOOL GetData(double wData);
	virtual BOOL GetData(COleDateTime& wData);
	virtual BOOL GetData(CString& strData);
	// 获取当前内存位置
	unsigned long GetCurrentPos();
public:
	/*================================================================*
	【函數】:	RemoveAllDataItem()
	【功能】:	删除所有数据将所占的内存清空
	【参数】:	
	【返回】:	返回BOOL类型,成功为TRUE,否则为FALSE
	【例子】:	
	【注意】:	
	*================================================================*/
	virtual BOOL	RemoveAllDataItem();

	/*================================================================*
	【函數】:	GetData()
	【功能】:	获取连续内存地址
	【参数】:	
	【返回】:	返回指向内存的首地址
	【例子】:	
	【注意】:	
	*================================================================*/
	virtual LPVOID  GetData();

	/*================================================================*
	【函數】:	GetDataSize()
	【功能】:	获取连续内存的大小
	【参数】:	
	【返回】:	返回指向内存的大小
	【例子】:	
	【注意】:	
	*================================================================*/
	virtual DWORD	GetDataSize();
protected:
	double VarToDouble(COleVariant* pvData);
protected:
	// 数据大小
	UINT m_uDataSize;
	// 数据
	LPVOID m_pData;
	// 内存需要删除标志
	bool m_bMustClean;
	unsigned long m_pCurDataPos;
private:
	CRITICAL_SECTION CRITICAL_LOCK;
};
#endif // !defined(AFX_DATAPARSER_H__C18BF820_ED69_42B0_A8F9_9570387F753C__INCLUDED_)

#include "stdafx.h"
#include "WSDataParser.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

CDataParser::CDataParser()
{
	m_bMustClean = true;
	m_pData = NULL;
	m_uDataSize = 0;
	m_pCurDataPos = 0;
	InitializeCriticalSection( &CRITICAL_LOCK);
}

CDataParser::~CDataParser()
{
	RemoveAllDataItem();
	DeleteCriticalSection(&CRITICAL_LOCK);
}
double CDataParser::VarToDouble(COleVariant* pvData)
{
	double dfData;
	COleVariant vData;
	
	vData = *pvData;
	
	switch(pvData->vt)
	{
	case VT_I1:
		dfData = (double)vData.cVal ;
		break;
	case VT_UI1:
		dfData = (double)vData.bVal;
		break;
	case VT_I2:
		dfData = (double)vData.iVal;
		break;
	case VT_UI2:
		dfData = (double)vData.uiVal;
		break;
	case VT_INT:
		dfData = (double)vData.intVal;
		break;
	case VT_UINT:
		dfData = (double)vData.uintVal;
		break;
	case VT_I4:
		dfData = (double)vData.lVal;
		break;
	case VT_UI4:
		dfData = (double)vData.ulVal;
		break;
	case VT_R4:
		dfData = (double)vData.fltVal;
		break;
	case VT_R8:
		dfData = (double)vData.dblVal;
		break;
	case VT_BOOL:
		if(vData.boolVal == VARIANT_FALSE)
			dfData = 0;
		else
			dfData = 1;
		break;
	case VT_CY:
	case VT_DATE:
	case VT_BSTR:
	case VT_DISPATCH:
	case VT_ERROR:
	case VT_VARIANT:
	case VT_UNKNOWN:
	case VT_DECIMAL:
	case VT_EMPTY:
	case VT_NULL:
	default:
		dfData = 0.0;
		break;
	}
	
	return dfData;
}
BOOL CDataParser::Add(LPVOID pData,int iLen)
{
	BOOL bSuccess = FALSE;
	EnterCriticalSection(&CRITICAL_LOCK);
	if(pData != NULL && iLen > 0)
	{
		if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);

		// 先构造类型
		DWORD dwDataVT = VT_VOID;
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
		m_uDataSize += 4;

		// 构造长度
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,&iLen,4);
		m_uDataSize += 4;

		// 构造值
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iLen, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,(char*)pData,iLen);
		
		m_uDataSize += iLen;
		bSuccess = TRUE;
	}
	LeaveCriticalSection(&CRITICAL_LOCK);
	return bSuccess;
}
BOOL CDataParser::Add(const CString& strData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);

	char *chAnsiCode = CUtility::ConvertStringToChar(strData);
	if(chAnsiCode)
	{
		//=================================================================================
		
		if(!m_pData) 
			m_pData = GlobalAlloc(GMEM_FIXED,1);
		
		// 先构造变量类型
		DWORD dwDataVT = VT_BSTR;
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
		m_uDataSize += 4;
		
		int istrVarNameLen = strlen(chAnsiCode);
		
		// 构造长度
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,&istrVarNameLen,4);
		m_uDataSize += 4;
		
		
		//构造值
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + istrVarNameLen, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,chAnsiCode,istrVarNameLen);
		
		m_uDataSize += istrVarNameLen;
		
		//=================================================================================
		
		delete chAnsiCode;
		chAnsiCode = NULL;

		bSuccess = TRUE;
	}
	LeaveCriticalSection(&CRITICAL_LOCK);
	return bSuccess;
}
BOOL CDataParser::Add(WORD wData)
{
	BOOL bSuccess = FALSE;

	EnterCriticalSection(&CRITICAL_LOCK);
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_UI2;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	bSuccess = TRUE;
	//=================================================================================
	LeaveCriticalSection(&CRITICAL_LOCK);
	return bSuccess;
}
BOOL CDataParser::Add(DWORD wData)
{
	BOOL bSuccess = FALSE;

	EnterCriticalSection(&CRITICAL_LOCK);

	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_UI4;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);
	
	return bSuccess;
}
BOOL CDataParser::Add(BOOL wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_BOOL;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);
	
	return bSuccess;
}
BOOL CDataParser::Add(BYTE wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_UI1;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(char wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_I1;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(short wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_I2;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(long wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_I4;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(float wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_R4;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(double wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_R8;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(const COleDateTime& wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_DATE;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(double);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData.m_dt,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(COleVariant* pvData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);

	if(pvData)
	{
		if(!m_pData) 
			m_pData = GlobalAlloc(GMEM_FIXED,1);

		COleVariant nVarData = *pvData;
		// 构造数据类型
		DWORD dwvDataVT = pvData->vt;
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,&dwvDataVT,4);
		m_uDataSize += 4;

		double dbData = VarToDouble(pvData);
		switch(dwvDataVT)
		{
		case VT_UI1:	//Byte                    bVal;
			{
				BYTE VarDataTmp = (BYTE)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 1, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,1);
				m_uDataSize += 1;
			}break;
		case VT_I1:		//char                    cVal;
			{
				char VarDataTmp = (char)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 1, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,1);
				m_uDataSize += 1;
			}break;
		case VT_I2:		//Short                   iVal;
			{
				short VarDataTmp = (short)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 2, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,2);
				m_uDataSize += 2;
			}break;
		case VT_UI2:	//unsigned short          uiVal;
			{
				WORD VarDataTmp = (WORD)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 2, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,2);
				m_uDataSize += 2;
			}break;
		case VT_INT:	//int                     intVal;
			{
				int VarDataTmp = (int)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,4);
				m_uDataSize += 4;
			}break;
		case VT_UINT:	//unsigned int            uintVal;
			{

				DWORD VarDataTmp = (DWORD)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,4);
				m_uDataSize += 4;
			}break;
		case VT_I4:		//long                    lVal;
			{
				long VarDataTmp = (long)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,4);
				m_uDataSize += 4;
			}break;
		case VT_UI4:	//unsigned long           ulVal;
			{
				unsigned long VarDataTmp = (unsigned long)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,4);
				m_uDataSize += 4;
			}break;
		case VT_R4:		//float                   fltVal;
			{
				float VarDataTmp = (float)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,4);
				m_uDataSize += 4;
			}break;
		case VT_R8:		//double                  dblVal;
			{
				double VarDataTmp = (double)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 8, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,8);
				m_uDataSize += 8;
			}break;
		case VT_BOOL:	//VARIANT_BOOL            boolVal;
			{
				bool VarDataTmp = (dbData == 0.0) ? false : true;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 1, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,1);
				m_uDataSize += 1;
			}break;
		case VT_DATE:	//DATE                    date;
			{
				DATE VarDataTmp = nVarData.date;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 8, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,8);
				m_uDataSize += 8;
			}break;
		case VT_BSTR:	//BSTR                    bstrVal;
			{
				CString strData = nVarData.bstrVal;
				int iLen = strData.GetLength();
				
				// 先写长度
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&iLen,4);
				m_uDataSize += 4;
				
				// 写字符串
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iLen, GMEM_MOVEABLE);

				char *chAnsiCode = CUtility::ConvertStringToChar(strData);
				if(chAnsiCode)
				{
					CopyMemory((char*)m_pData + m_uDataSize,chAnsiCode,iLen);
				
					delete chAnsiCode;
					chAnsiCode = NULL;
				}
				m_uDataSize += iLen;
			}break;
		case VT_EMPTY:
			{

			}break;
		case VT_NULL:
			{

			}break;
		default:
			break;
		}
		bSuccess = TRUE;
	}
	
	LeaveCriticalSection(&CRITICAL_LOCK);
	
	return bSuccess;
}

BOOL CDataParser::RemoveAllDataItem()
{
	if(m_bMustClean)
	{
		if(m_pData)
		{
			GlobalFree(m_pData);
			m_pData = NULL;
		}
	}
	m_uDataSize = 0;
	return TRUE;
}

LPVOID CDataParser::GetData()
{
	return m_pData;
}

DWORD CDataParser::GetDataSize()
{
	return m_uDataSize;
}
//============================================================================================
void CDataParser::InitData( void *pData,unsigned long nDataSize)
{
	m_pCurDataPos = 0;
	m_pData = pData;
	m_uDataSize = nDataSize;
	// 数据由应用层传进来，在析构中不能释放
	m_bMustClean = false;
}
unsigned long CDataParser::GetCurrentPos()
{
	return m_pCurDataPos;
}
BOOL CDataParser::GetData(COleVariant& pvData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			pvData.vt = dwDataVT;
			switch(dwDataVT)
			{
			case VT_UI1:	//Byte                    bVal;
				{
					// 构造值
					memcpy(&pvData.bVal,(char*)m_pData + m_pCurDataPos, 1);
					m_pCurDataPos += 1;
					bSuccess = TRUE;
				}break;
			case VT_I1:		//char                    cVal;
				{
					memcpy(&pvData.cVal,(char*)m_pData + m_pCurDataPos, 1);
					m_pCurDataPos += 1;
					bSuccess = TRUE;
				}break;
			case VT_I2:		//Short                   iVal;
				{
					memcpy(&pvData.iVal,(char*)m_pData + m_pCurDataPos, 2);
					m_pCurDataPos += 2;
					bSuccess = TRUE;
				}break;
			case VT_UI2:	//unsigned short          uiVal;
				{
					memcpy(&pvData.uiVal,(char*)m_pData + m_pCurDataPos, 2);
					m_pCurDataPos += 2;
					bSuccess = TRUE;
				}break;
			case VT_INT:	//int                     intVal;
				{
					memcpy(&pvData.intVal,(char*)m_pData + m_pCurDataPos, 4);
					m_pCurDataPos += 4;
					bSuccess = TRUE;
				}break;
			case VT_UINT:	//unsigned int            uintVal;
				{
					memcpy(&pvData.uintVal,(char*)m_pData + m_pCurDataPos, 4);
					m_pCurDataPos += 4;
					bSuccess = TRUE;
				
				}break;
			case VT_I4:		//long                    lVal;
				{
					memcpy(&pvData.lVal,(char*)m_pData + m_pCurDataPos, 4);
					m_pCurDataPos += 4;
					bSuccess = TRUE;
				}break;
			case VT_UI4:	//unsigned long           ulVal;
				{
					memcpy(&pvData.ulVal,(char*)m_pData + m_pCurDataPos, 4);
					m_pCurDataPos += 4;
					bSuccess = TRUE;
				}break;
			case VT_R4:		//float                   fltVal;
				{
					memcpy(&pvData.fltVal,(char*)m_pData + m_pCurDataPos, 4);
					m_pCurDataPos += 4;
					bSuccess = TRUE;
				}break;
			case VT_R8:		//double                  dblVal;
				{
					memcpy(&pvData.dblVal,(char*)m_pData + m_pCurDataPos, 8);
					m_pCurDataPos += 8;
					bSuccess = TRUE;
				}break;
			case VT_BOOL:	//VARIANT_BOOL            boolVal;
				{
					BOOL bData = FALSE;
					memcpy(&bData,(char*)m_pData + m_pCurDataPos, 1);
					pvData.boolVal = (bData == TRUE ) ? VARIANT_TRUE : VARIANT_FALSE;
					m_pCurDataPos += 1;
					bSuccess = TRUE;
				}break;
			case VT_DATE:	//DATE                    date;
				{
					memcpy(&pvData.date,(char*)m_pData + m_pCurDataPos, 8);
					m_pCurDataPos += 8;
					bSuccess = TRUE;
				}break;
			case VT_BSTR:	//BSTR                    bstrVal;
				{
					// 先读长度
					DWORD dwDataLen = 0;
					memcpy(&dwDataLen,(char*)m_pData + m_pCurDataPos, 4);
					m_pCurDataPos += 4;

					char *chName = new char[dwDataLen + 1];
					memcpy((char*)chName,(char*)m_pData + m_pCurDataPos,dwDataLen);
					chName[dwDataLen] = '\0';
					m_pCurDataPos += dwDataLen;

					CString strData = CString(chName);
					pvData = strData;
					delete []chName;
					bSuccess = TRUE;
				}break;
			case VT_EMPTY:
				{
					
				}break;
			case VT_NULL:
				{
					
				}break;
			default:
				{
					// 当前索引退回上一次位置
					m_pCurDataPos -= 4;
					bSuccess = FALSE;
				}break;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(WORD &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_UI2)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos, 2);
				m_pCurDataPos += 2;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(DWORD &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_UI4)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos, 4);
				m_pCurDataPos += 4;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(LPVOID pData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_VOID)
			{
				// 先构造长度
				DWORD dwDataLen = 0;
				memcpy(&dwDataLen,(char*)m_pData + m_pCurDataPos,  4);
				m_pCurDataPos += 4;

				// 构造值
				memcpy(&pData,(char*)m_pData + m_pCurDataPos, dwDataLen);
				m_pCurDataPos += dwDataLen;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(BOOL &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_BOOL)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos, 1);
				m_pCurDataPos += 1;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(BYTE &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_UI1)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos, 1);
				m_pCurDataPos += 1;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(char &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_I1)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos, 1);
				m_pCurDataPos += 1;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(short &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_I2)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos, 2);
				m_pCurDataPos += 2;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(long &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_I4)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos,4);
				m_pCurDataPos += 4;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(float &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_R4)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos,4);
				m_pCurDataPos += 4;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(double wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_R8)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos,8);
				m_pCurDataPos += 8;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(COleDateTime& wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_DATE)
			{
				// 构造值
				memcpy(&wData.m_dt,(char*)m_pData + m_pCurDataPos,8);
				m_pCurDataPos += 8;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(CString& strData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_BSTR)
			{
				// 先构造长度
				DWORD dwDataLen = 0;
				memcpy(&dwDataLen,(char*)m_pData + m_pCurDataPos,  4);
				m_pCurDataPos += 4;
				
				char *chName = new char[dwDataLen + 1];

				// 构造值
				memcpy((char*)chName,(char*)m_pData + m_pCurDataPos, dwDataLen);
				chName[dwDataLen] = '\0';
				strData = CString(chName);
				delete []chName;

				m_pCurDataPos += dwDataLen;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}


您可能感兴趣的与本文相关的镜像

ACE-Step

ACE-Step

音乐合成
ACE-Step

ACE-Step是由中国团队阶跃星辰（StepFun）与ACE Studio联手打造的开源音乐生成模型。 它拥有3.5B参数量，支持快速高质量生成、强可控性和易于拓展的特点。 最厉害的是，它可以生成多种语言的歌曲，包括但不限于中文、英文、日文等19种语言

使用机器学习进行NSFW内容检测
DkVhdl的博客
09-19 2037
NSFW（Not Safe for Work）内容检测是一项关键的任务，旨在识别和过滤出不适宜在工作场所或公共环境中展示的内容，例如色情、暴力或其他违反社区准则的图像或视频。通过收集和准备数据、选择适当的模型、进行数据预处理、训练和评估模型，最终可以得到一个准确性较高的NSFW内容检测器。通过收集和准备数据、选择适当的模型、进行数据预处理、训练和评估模型，最终可以得到一个准确性较高的NSFW内容检测器。使用测试数据集来计算模型的准确率、精确率、召回率等指标，以评估模型在NSFW内容检测任务上的表现。
AI作画工具 stable-diffusion-webui 本地部署 多种模型 可生成NSFW
weixin_41259045的博客
03-14 1万+
AI作画最近非常火热啊，本文是在使用N卡的电脑上，本地部署stable-diffusion-webui前端+替换默认的模型，实现生成高质量的二次元图像，并且可以不受限制的生成图片。
NSFW、工作不安全 (Not Safe for Work)
qq_15821487的博客
08-02 1万+
nsfw什么颜色 Casimior PT/Shutterstock 卡西米PT /快门 NSFW is an odd, versatile internet acronym that’s found its way into internet articles and social media posts. But what does NSFW mean, where’d it come from, and how do you use it? Do...
Node.js文件监控库nsfw实战解析
最新发布
weixin_35749786的博客
09-12 1236
在现代前端开发中，实时响应文件变化是提升开发效率的关键。nsfw库通过监听文件系统事件来实现这一点，其背后依赖的是操作系统提供的原生文件监控接口。本章深入剖析了nsfw库的底层文件监控机制，从操作系统级别到Node.js层面的实现方式，再到nsfw的高性能优势进行了全面分析。同时，详细介绍了nsfw支持的事件类型、事件触发频率控制策略以及多事件绑定与解耦设计。
模型是如何训练出来的
热门推荐
实践求真知
04-15 1万+
一 模型里的内容和意义一个标准的模型结构分为输入、中间节点、输出三大部分，而如何让这三部分连通起来学习规则并可进行计算，则是框架TensorFlow所做的事情。TensorFlow将中间节点及节点间的运算关系（OPS）定义在自己内部的一个“图”上，全通过一个“会话（session）”进行图中OPS的具体运算。可以这样理解：“图”是静态的，无论做任何加、减、乘、除，它们只是将关系搭建在一起，不会有任...
nsfw模型的搭建（复现实操）
Kirito_UGO的博客
03-15 5340
nsfw tf2
图片风控NSFW(not suit for work)-1 tensorflow2模型重构
weixin_42529756的博客
10-09 7656
tensorflow2 ResNet50 nsfw 图片风控 not suit for work
tensowflow 训练 远程提交_tf.saved_model.save模型导出、TensorFlow Serving模型部署、TensorBoard中的HParams 超参数调优...
weixin_32753181的博客
01-12 845
日萌社人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战(不定时更新)4.11 综合案例：模型导出与部署学习目标目标掌握TensorFlow模型的导出(saved_model格式)掌握Tensorflow模型的部署掌握TensorFlow模型的客户端调用掌握TensorFlow模型的超参数调优使用应用无4.11.1 TensorFl...
关于如何在k8s中搭建一个nsfw黄图鉴定模型
小王同学的博客
11-25 1140
上述Dockerfile为一个base的dockerfile，由于我们的项目是流水线自动化部署，每次代码更新都会制作一个最新的镜像，但是上述这种下载依赖的重复逻辑不想每次制作镜像的时候都重复执行，所以先制作一个只下载环境的base镜像，将制作好的镜像传到镜像仓库，假设我的镜像是 wf.com/base/huggingface:2.0。下面手把手教你如何将huggingface中的黄图检测模型部署到自己的服务器上去。上述代码就是启动一个80端口，接收一个url参数，将url对应的图片识别是否涉黄。
精选资源
model_trans_模型轉換_h52onnx_源码
10-04
标题提到的"model_trans_模型轉換_h52onnx_源码"涉及到的是将基于Keras的H5模型转换为ONNX（Open Neural Network Exchange）格式的过程。这种转换对于模型的跨平台部署和优化至关重要。下面将详细阐述这一过程及其...
nsfw-model-conda环境
03-29
部署该模型（https://github.com/GantMan/nsfw_model）的conda虚拟环境配置文件。 tf24；python 3.8；
nsfw_model：NSFW检测器的Keras模型
02-04
NSFW检测机器学习模型 接受60多种数据训练，以识别： drawings -安全用于工程图（包括动画） hentai -无尽的和色情的图画 neutral -适用于工作中性图像 porn -色情图片，性行为 sexy -色情图片，而不是色情图片 该模型为动力- 当前状态： 基于Inception V3，具有以下混淆矩阵的93％精度。 查看_art文件夹以了解此模型的先前版本。 要求： keras（测试版本> 2.0.0）tensorflow> = 2.1.0 用法 用于库的编程使用。 from nsfw_detector import predict model = pred
tensorflow-open_nsfw：Yahoo的Open NSFW模型的Tensorflow实现
02-06
Yahoo的开放NSFW模型的Tensorflow实现 该存储库包含以tensorflow重写的的实现。 原始重量已使用提取 。 您可以在data/open_nsfw-weights.npy找到它们。 先决条件 所有代码均应与Python 3.6和Tensorflow 1.x （经1.12测试）兼容。 该模型的实现可以在model.py找到。 用法 > python classify_nsfw.py -m data/open_nsfw-weights.npy test.jpg Results for 'test.jpg' SFW score: 0.9355766177177429 NSF
基于 NSFW Model 色情图片识别鉴黄 后面更新视频检测.zip
04-04
基于 NSFW Model 色情图片识别鉴黄 后面更新视频检测 项目背景： 随着互联网的快速发展，网络上的信息量呈现出爆炸式的增长。然而，互联网上的内容良莠不齐，其中不乏一些不良信息，如色情、暴力等。这些信息对青少年的健康成长和社会风气产生了不良影响。为了净化网络环境，保护青少年免受不良信息的侵害，我国政府加大了对网络内容的监管力度。在此背景下，本项目应运而生，旨在实现对网络图片和视频的自动识别与过滤，助力构建清朗的网络空间。 项目简介： 本项目基于 NSFW（Not Safe For Work）Model，利用深度学习技术对色情图片进行识别与鉴黄。NSFW Model 是一种基于卷积神经网络（CNN）的图像识别模型，通过学习大量的色情图片和非色情图片，能够准确地判断一张图片是否含有色情内容。本项目在 NSFW Model 的基础上，进一步优化了模型结构，提高了识别的准确率和效率。 项目功能： 色情图片识别：用户上传图片后，系统会自动调用 NSFW Model 对图片进行识别，判断图片是否含有色情内容。如果含有色情内容，系统会给出相应的提示，并阻止图片的传播。 视频检测：针对网络视频，本项目采用帧提取技术，将视频分解为一帧帧图片，然后使用 NSFW Model 对这些图片进行识别。如果检测到含有色情内容的图片，系统会给出相应的提示，并阻止视频的传播。 实时监控：本项目可应用于网络直播、短视频平台等场景，实时监控画面内容，一旦检测到含有色情内容的画面，立即进行屏蔽处理，确保网络环境的纯洁。
python-nsfw:使用Caffe和Yahoo的open_nsfw模型分析图像的Python包
05-18
python-nsfw 使用和模型分析图像的Python软件包。 先决条件 python-nsfw需要Python 3并在与Caffe兼容的系统上运行。 咖啡 如果您使用的是macOS和 ，那么安装的最简单方法是使用Homebrew： brew install caffe 或者，您可以使用 Linux映像（例如 ）并安装必要的依赖项： apt update && apt install caffe-cpu python3 python3-pip wget 安装 python-nsfw可以使用安装： pip3 install nsfw 用法 import PIL . Image as Image from nsfw import classify image = Image . open ( "/path/to/image.jpg" ) sfw , nsfw = classif
【亲测免费】 推荐项目：NSFW模型 —— 智能图像分类的高效工具
gitblog_01194的博客
08-24 2689
在数字化时代，内容管理变得日益重要，特别是在过滤不适合工作环境的内容方面。今天，我们来深入探讨一个强大的开源解决方案——**NSFW Model**，一个专门用于识别和分类不适宜工作的图像（Not Suitable for Work）的强大工具。 ## 项目介绍 **NSFW Model** 是一款高效且易于部署的图像分类器，能够准确地将图像归类为“性感”、“动漫画风”、“一般”、“色情”或“...
探索NSFW模型：智能内容筛选的新篇章
gitblog_00046的博客
04-25 2419
探索NSFW模型：智能内容筛选的新篇章 nsfw_model Keras model of NSFW detector 项目地址: https://gitcode.com/gh_mirrors/ns/nsfw_model ...
python NSFW Model 图片识别鉴黄 后面更新视频检测
freedom_fd的博客
06-17 4614
基于 NSFW Model 色情图片识别鉴黄 后面更新视频检测
图片风控NSFW(not suit for work)-2 基于tf2模型微调
weixin_42529756的博客
12-13 1358
使用tensorflow2 对yahoo开源NSFW模型微调
本地部署nsfw
05-13
### 如何在本地部署 NSFW 模型或服务 要在本地环境中成功部署 NSFW（不适宜工作场合内容）检测模型或服务，以下是详细的说明： #### 准备环境 为了确保能够顺利运行模型和服务，需要安装必要的依赖项。这些工具和库包括但不限于以下几类： - **Python 环境**: 推荐使用 Python 3.7 或更高版本。 - **Transformers 库**: 提供加载预训练模型的功能[^1]。 - **PyTorch/TensorFlow**: 支持深度学习框架的计算需求。 - **Pillow (PIL)**: 处理图像文件并将其转换为适合输入模型的形式。 具体命令如下所示： ```bash pip install transformers torch Pillow ``` #### 加载模型与测试 通过 Hugging Face 的 `transformers` 工具包可以直接访问已有的 NSFW 图片分类模型。例如，可以采用名为 `"Falconsai/nsfw_image_detection"` 的公开模型来完成此任务[^1]。 下面是一个简单的代码片段展示如何加载该模型并对单张图片执行预测操作： ```python from PIL import Image from transformers import pipeline def classify_nsfw(image_path): # 打开指定路径下的图片文件 img = Image.open(image_path) # 初始化 image-classification 流水线对象，并指明使用的特定模型名称 classifier = pipeline("image-classification", model="Falconsai/nsfw_image_detection") # 对传入的图片调用流水线方法得到其类别标签及其置信度分数列表形式的结果 result = classifier(img) return result if __name__ == "__main__": test_img_path = "<your_test_image>" output_results = classify_nsfw(test_img_path) print(output_results) ``` 注意替换 `<your_test_image>` 成实际存在的图片绝对或者相对地址字符串值之前再尝试运行以上脚本。 #### 构建 RESTful API 服务 如果希望进一步扩展功能至 Web 应用程序层面，则可考虑利用 Flask/Django 这样的轻量级 web 开发框架构建起支持 HTTP 请求交互的服务端接口。这里给出基于 FastAPI 实现的一个简单例子作为示范用途: ```python import uvicorn from fastapi import FastAPI, File, UploadFile from PIL import Image from io import BytesIO from typing import List from pydantic import BaseModel app = FastAPI() class Prediction(BaseModel): label: str score: float @app.post("/predict/", response_model=List[Prediction]) async def predict(file: UploadFile = File(...)): try: contents = await file.read() pil_image = Image.open(BytesIO(contents)) clf_pipeline = pipeline('image-classification', model='Falconsai/nsfw_image_detection') predictions = clf_pipeline(pil_image) formatted_preds = [{"label": pred['label'], "score": round(pred['score'], 4)} for pred in predictions] return formatted_preds except Exception as e: raise ValueError(f"Error processing uploaded file {e}") if __name__ == '__main__': uvicorn.run(app, host='0.0.0.0', port=8000) ``` 启动服务器之后即可向 `/predict/` 路径发送 POST 请求附带上传待分析的目标图片获取返回结果了。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值