缩放打印文件（prt,prn）

于 2023-11-02 09:58:18 发布
阅读量611 收藏 4
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuyouzhiyi/article/details/134175404
版权

打印机支持的文件为 prt 或者prn
这里介绍如何缩放打印文件

打印文件格式如下：

struct SRipHeader
{
	int		nSignature;			 
	int		nVersion;			 
	int		nImageWidth;		// RIP Image pixel width
	int		nImageHeight;		// RIP Image pixel height

	int		nImageColorNum;		//RIP image Color number include 4 (YMCK) 6 YMCKLcLm 8 YMCKLcLmOrGr

	int		nImageColorDeep;	//1,2,4,8 RIP image output bit per color
	int		nImageResolutionX;	//RIP image X resolution, 180,360,720
	int		nImageResolutionY;	//RIP Image Y resolution, 186,372,558,744

	int		nCompressMode;		// First version should be 0 , no compress mode
	int		nBytePerLine;		//First version used for no compress mode
	int		nBidirection;		// Bidirection for 1, Unidirection for 0
	int		nPass;				//1,2,3,4,6,8,12 Pass

	int		nSpeed;				//High speed 0 Middle speed 1 Low Speed 2

	///Version 2 Change
	unsigned char  nExtraChannel;
	unsigned char  nVSDMode;					//Set VSD Mode for EPSON PrintHead driver
	unsigned char  nEpsonPrintMode;				// High Qulity :0 ，High Speed: 1

	unsigned char	nChannelColorName[16];		//color for each channel
	unsigned char	biCompression;				// whether or not use data compression;0:no Compression;1:RLE4;2:RLE8
	int 			nPreviewImgByteSize;		// If the preview is included, it is the number of bytes in the preview, otherwise it should be 0.
	unsigned char	bPreviewImg;				// Whether it contains a preview;0:no preview;1:bmp(24bit,rgb);
	unsigned char   nReserve[2];				//Fill with 0

	unsigned char  nPrtNum;
	unsigned char  nChannel[4];
};

注意：读文件时，首先需要解析文件头，如上
假设是4色（ymck），位深（nImageColorDeep）为2的打印文件，则文件内容如下：
Y : 00 01 01 10 11 10
M: 11 10 01 11 00 00
C: 00 10 01 00 11 00
K : 00 00 01 00 00 01
也就是说我们看见的图片的每一行对应打印文件的四行，每2位代表一个颜色

图片的宽度为nImageWidth，那么文件这一行的长度为：（nImageWidth * nImageColorDeep+7）/8
因为文件必须为 8位对齐

最邻近算法缩放图片

#pragma once
#include "PrtFile.h"
#include <string>
#include<fstream> 
#include <mutex>
#include "windows.h"

class CZoomPrtFile :
    public CPrtFile
{
public:
	CZoomPrtFile();
	virtual ~CZoomPrtFile();
	bool Open(LPCTSTR szFileName);
	
	virtual void Close();
	virtual int Seek(uint64 pos);
	virtual int Read(void* buf, int size, int count);
	virtual int ReadLine(BYTE* pData, int nLine, int xStart, int nLen);
	virtual void AbortRead();

	void setZoom(size_t zoomWidth, size_t zoomHeight);
	bool saveZoomPrtFile(const std::string& prtFile,size_t zoomWidth, size_t zoomHeight);
	bool saveZoomPrtFile(const std::string& prtFile);
	void zoomPrtFileparallel(BYTE* pTargetData);
	/*void zoomPrtFileThreadProc(BYTE* pTargetData, int ColorNum);*/
	void zoomPrtFileThreadProc(BYTE* pTargetData, int start, int endRow);

private:
	void zoomPrtFile(BYTE* pTargetData);
	unsigned char getPixel(unsigned char* data, int x, int nImageColorDeep);
	void setPixel(unsigned char* data, int x, unsigned char pixel, int nImageColorDeep);
	bool writePrtFile(const std::string& prtFile, unsigned char* data, size_t outDataSize);
	unsigned char getPixel(unsigned char data, int x, int nImageColorDeep);
private:
	FILE* m_fp;
	bool m_bAbort;
	size_t m_zoomWidth;
	size_t m_zoomHeight;
	size_t m_perWidth;
	size_t m_perHeight;


	std::mutex fileMutex; // 文件锁
};

cpp

#include "CZoomPrtFile.h"
#include <Windows.h>
#include<vector>
#include <thread>
#include <chrono>
#include <iostream>
using namespace std;

CZoomPrtFile::CZoomPrtFile() :
	m_fp(NULL),
	m_bAbort(false),
	m_zoomWidth(-1),
	m_zoomHeight(-1)
{
}

CZoomPrtFile::~CZoomPrtFile()
{
	Close();
}

bool CZoomPrtFile::Open(LPCTSTR szFileName)
{
	m_fp = _wfsopen(szFileName, L"rb", _SH_DENYNO);

	if (!m_fp)
	{
		return false;
	}

	if (OpenPrt())
	{
		m_perWidth = m_header.nImageWidth;
		m_perHeight = m_header.nImageHeight;
		return true;
	}
	else
	{
		return false;
	}
}

void CZoomPrtFile::Close()
{
	if (m_fp)
	{
		fclose(m_fp);
		m_fp = NULL;
	}
}

int CZoomPrtFile::Seek(uint64 pos)
{
	return _fseeki64(m_fp, pos, SEEK_SET);
}

int CZoomPrtFile::Read(void* buf, int size, int count)
{
	//std::lock_guard<std::mutex> locker(fileMutex);
	return (int)fread(buf, size, count, m_fp);
}

int CZoomPrtFile::ReadLine(BYTE* pData, int nLine, int xStart, int nLen)
{
	//std::lock_guard<std::mutex> locker(fileMutex);  fseek和fread单独使用线程安全 fseek和fread联合使用需要加锁或者采用临界区
	Seek(sizeof(m_header) + (int64)nLine * m_header.nBytePerLine + xStart);
	Read(pData, 1, nLen);
	return 0;
	while (true)
	{
		if (m_bAbort)
		{
			break;
		}

		if (Seek(sizeof(m_header) + (int64)nLine * m_header.nBytePerLine + xStart) != 0)
		{
			Sleep(10);

			continue;
		}

		if (Read(pData, 1, nLen) != nLen)
		{
			Sleep(10);

			continue;;
		}
		else
		{
			return nLen;
		}
	}

	return 0;
}

void CZoomPrtFile::AbortRead()
{
	m_bAbort = true;
}



void CZoomPrtFile::setZoom(size_t zoomWidth, size_t zoomHeight)
{
	 m_zoomWidth = zoomWidth;
	 m_zoomHeight = zoomHeight;
}
bool CZoomPrtFile::saveZoomPrtFile(const std::string& prtFile,size_t zoomWidth, size_t zoomHeight)
{
	m_zoomWidth = zoomWidth;
	m_zoomHeight = zoomHeight;
	return saveZoomPrtFile(prtFile);
}

bool CZoomPrtFile::saveZoomPrtFile(const std::string& prtFile)
{
	// Get Start Time
	std::chrono::system_clock::time_point start = std::chrono::system_clock::now();
	bool ok = false;

	if (m_zoomWidth > 1 && m_zoomHeight > 1 && m_fp)
	{
		int nTargetLineByteSize = (m_zoomWidth * m_header.nImageColorDeep + 7) / 8;
		int nTargetDataSize = sizeof(m_header) + nTargetLineByteSize * m_header.nImageColorNum * m_zoomHeight;
		BYTE* pTargetData = new BYTE[nTargetDataSize];
		memset(pTargetData, 0, nTargetDataSize);
		SRipHeader zoomHeader(m_header);
		zoomHeader.nImageHeight = m_zoomHeight;
		zoomHeader.nImageWidth = m_zoomWidth;
		zoomHeader.nBytePerLine = nTargetLineByteSize;
		memcpy(pTargetData, &zoomHeader, sizeof(zoomHeader));

		zoomPrtFile(pTargetData);

		//zoomPrtFileparallel(pTargetData);

		ok=writePrtFile(prtFile, pTargetData, nTargetDataSize);
		delete[] pTargetData;
		// Get End Time
		auto end = std::chrono::system_clock::now();
		auto diff = std::chrono::duration_cast <std::chrono::milliseconds> (end - start).count();
		std::cout << prtFile<<" . Total Time Taken = " << diff << " milliseconds" << " . Total size = " << m_header.nBytePerLine* m_header.nImageHeight * m_header.nImageColorNum + sizeof(m_header) << "byte" 
			" . target file size = " << zoomHeader.nBytePerLine * zoomHeader.nImageHeight * zoomHeader.nImageColorNum + sizeof(zoomHeader) << std::endl;
	}
	return ok;
}


void CZoomPrtFile::zoomPrtFile(BYTE* pTargetData)
{
	float xRatio = static_cast<float>(m_perWidth - 1) / m_zoomWidth;
	float yRatio = static_cast<float>(m_perHeight - 1) / m_zoomHeight;
	int srcX=0, srcY=0;
	int nTargetLineSize = (m_zoomWidth * m_header.nImageColorDeep + 7) / 8;

	BYTE* pSourceLineData = new BYTE[m_header.nBytePerLine];
	for (size_t row = 0; row < m_zoomHeight; row++) 
	{
		srcY = static_cast<int>(yRatio * row);
		for (int ColorNum = 0; ColorNum < m_header.nImageColorNum; ColorNum++)
		{

			memset(pSourceLineData, 0, m_header.nBytePerLine);
			ReadLine(pSourceLineData, srcY * m_header.nImageColorNum + ColorNum, 0, m_header.nBytePerLine);

			for (size_t column = 0; column < m_zoomWidth; column++) 
			{
				srcX = static_cast<int>(xRatio * column);
				// 获取源图像的 bit像素值
				unsigned char srcValue = getPixel(pSourceLineData, srcX, m_header.nImageColorDeep);
				int y = (row * m_header.nImageColorNum + ColorNum) * nTargetLineSize + sizeof(m_header);
				// 设置目标图像的2bit像素值
				setPixel(pTargetData+y,column, srcValue, m_header.nImageColorDeep);
			}
		}
	}

	delete[] pSourceLineData;
}
void CZoomPrtFile::zoomPrtFileparallel(BYTE* pTargetData)
{
	std::vector<std::thread> threadPool;
	int threadNum = 8;
	int step = m_zoomHeight / threadNum;
	for (int i = 0; i < threadNum -1; i++)
	{
		threadPool.push_back(std::thread(&CZoomPrtFile::zoomPrtFileThreadProc, this, pTargetData, i* step,(i+1)* step));
	}

	zoomPrtFileThreadProc(pTargetData, (threadNum - 1) * step, m_zoomHeight);
	for (int i = 0; i < threadNum - 1; i++)
	{
		threadPool[i].join();
	}
}

void CZoomPrtFile::zoomPrtFileThreadProc(BYTE* pTargetData, int start, int endRow)
{
	float xRatio = static_cast<float>(m_perWidth - 1) / m_zoomWidth;
	float yRatio = static_cast<float>(m_perHeight - 1) / m_zoomHeight;
	int srcX = 0, srcY = 0;
	int nTargetLineSize = (m_zoomWidth * m_header.nImageColorDeep + 7) / 8;

	BYTE* pSourceLineData = new BYTE[m_header.nBytePerLine];
	for (size_t row = start; row < endRow; row++)
	{
		srcY = static_cast<int>(yRatio * row);
		for (int ColorNum = 0; ColorNum < m_header.nImageColorNum; ColorNum++)
		{

			memset(pSourceLineData, 0, m_header.nBytePerLine);
			ReadLine(pSourceLineData, srcY * m_header.nImageColorNum + ColorNum, 0, m_header.nBytePerLine);

			for (size_t column = 0; column < m_zoomWidth; column++)
			{
				
				srcX = static_cast<int>(xRatio * column);
				// 获取源图像的 bit像素值
				int byteIndex = srcX * m_header.nImageColorDeep / 8; // 字节索引

				unsigned char srcValue = getPixel(pSourceLineData[byteIndex], srcX, m_header.nImageColorDeep);
				int y = (row * m_header.nImageColorNum + ColorNum) * nTargetLineSize + sizeof(m_header);
				// 设置目标图像的2bit像素值
				setPixel(pTargetData + y, column, srcValue, m_header.nImageColorDeep);
			}
		}
	}

	delete[] pSourceLineData;
}
//
//void CZoomPrtFile::zoomPrtFileThreadProc(BYTE* pTargetData, int ColorNum)
//{
//	float xRatio = static_cast<float>(m_perWidth - 1) / m_zoomWidth;
//	float yRatio = static_cast<float>(m_perHeight - 1) / m_zoomHeight;
//	int srcX = 0, srcY = 0;
//
//	int nTargetLineSize = (m_zoomWidth * m_header.nImageColorDeep + 7) / 8;
//	BYTE* pSourceLineData = new BYTE[m_header.nBytePerLine];
//	for (size_t row = 0; row < m_zoomHeight; row++)
//	{
//		srcY = static_cast<int>(yRatio * row);
//		memset(pSourceLineData, 0, m_header.nBytePerLine);
//		ReadLine(pSourceLineData, srcY * m_header.nImageColorNum + ColorNum, 0, m_header.nBytePerLine);
//
//		for (size_t column = 0; column < m_zoomWidth; column++)
//		{
//			srcX = static_cast<int>(xRatio * column);
//			// 获取源图像的 bit像素值
//			unsigned char srcValue = getPixel(pSourceLineData, srcX, m_header.nImageColorDeep);
//			// 设置目标图像的2bit像素值
//			int y = (row * m_header.nImageColorNum + ColorNum)* nTargetLineSize + sizeof(m_header);
//			setPixel(pTargetData+y, column, srcValue, m_header.nImageColorDeep);
//		}
//	}
//	delete[] pSourceLineData;
//	return;
//}

unsigned char CZoomPrtFile::getPixel(unsigned char* data, int x, int nImageColorDeep)
{
	//unsigned char存储 8/int nImageColorDeep 个 int nImageColorDeep bit像素 ,其中 nImageColorDeep ：1,2,4,8 RIP image output bit per color
	int byteIndex = x * nImageColorDeep / 8; // 字节索引
	int bitIndex = (x * nImageColorDeep) % 8; // 位索引

	// 创建掩码
	unsigned char mask = (1 << nImageColorDeep) - 1;
	//std::lock_guard<std::mutex> locker(fileMutex);
	// 位运算提取像素

	unsigned char pixel;
	{ 
		std::lock_guard<std::mutex> locker(fileMutex); 
		pixel = data[byteIndex];
	}
	pixel = (pixel >> bitIndex) & mask;

	return pixel;
}

unsigned char CZoomPrtFile::getPixel(unsigned char data, int x, int nImageColorDeep)
{
	//unsigned char存储 8/int nImageColorDeep 个 int nImageColorDeep bit像素 ,其中 nImageColorDeep ：1,2,4,8 RIP image output bit per color
	int byteIndex = x * nImageColorDeep / 8; // 字节索引
	int bitIndex = (x * nImageColorDeep) % 8; // 位索引

	// 创建掩码
	unsigned char mask = (1 << nImageColorDeep) - 1;
	//std::lock_guard<std::mutex> locker(fileMutex);
	// 位运算提取像素
	unsigned char pixel = (data >> bitIndex) & mask;

	return pixel;
}

void CZoomPrtFile::setPixel(unsigned char* data,int x, unsigned char pixel, int nImageColorDeep)
{
	
	//int y = (int64)nLine * nTargetLineSize + sizeof(m_header);
	int byteIndex = x * nImageColorDeep / 8;//在第y行的byte的位置
	int bitIndex = (x * nImageColorDeep) % 8;

	// 创建掩码 
	unsigned char mask = (1 << nImageColorDeep) - 1;
	// 清空原像素
	
	unsigned char temp = data[byteIndex];
	temp &= ~(mask << bitIndex);
	temp |= (pixel & mask) << bitIndex;
	//std::lock_guard<std::mutex> locker(fileMutex);
	data[byteIndex] = temp;
	//data[byteIndex] &= ~(mask << bitIndex);

	 设置新像素  
	//data[ byteIndex] |= (pixel & mask) << bitIndex;

}

bool CZoomPrtFile::writePrtFile(const std::string& prtFile, unsigned char* data, size_t outDataSize)
{
	if (data == nullptr) {
		return false;
	}
	//Write file
	std::ofstream outFile;
	outFile.open(prtFile, std::ofstream::binary);
	if (!outFile.is_open()) {
		return false;
	}
	for (size_t i = 0; i < outDataSize; i++) {
		outFile << data[i];
	}
	outFile.close();
	return true;

}

main

#include "CZoomPrtFile.h"
#include <iostream>
#include <fstream>
#include"base.h"
using namespace std;

void test()
{
	std::ifstream ifs("D:\\doc\\prt\\1111111.prn");
	if (!ifs.is_open())
	{
		return;
	}
	ifs.seekg(0, ios_base::end);  //先把文件输入流指针定位到文档末尾来获取文档的长度
	int length = ifs.tellg();

	cout << " 1111111.prn size is " << length << endl;
}

int main()
{
	test();
	CZoomPrtFile zoomPrtFile;
	zoomPrtFile.Open(L"D:\\doc\\prt\\1111111.prn");

	cout << " test 单线程"<< endl;
	zoomPrtFile.saveZoomPrtFile("D:\\doc\\prt\\1111111Zoom05.prn", 3259 * 0.5, 4605 * 0.5);
	zoomPrtFile.saveZoomPrtFile("D:\\doc\\prt\\1111111Zoom08.prn", 3259 * 0.8, 4605 * 0.8); 
	zoomPrtFile.saveZoomPrtFile("D:\\doc\\prt\\1111111Zoom15.prn", 3259 * 1.5, 4605 * 1.5);
	zoomPrtFile.saveZoomPrtFile("D:\\doc\\prt\\1111111Zoom20.prn", 3259 * 2, 4605 * 2);
	return 0;
}

 /*
 处理的速度要到至少500MB/S 

 test 多线程 8个线程
D:\doc\prt\1111111Zoom05.prn . Total Time Taken = 769 milliseconds . source size = 26303844 byte  target file size = 6574596， 
D:\doc\prt\1111111Zoom08.prn . Total Time Taken = 1738 milliseconds . source size = 26303844 byte  target file size = 16813860
D:\doc\prt\1111111Zoom15.prn . Total Time Taken = 5812 milliseconds . source size = 26303844 byte  target file size = 59082562
D:\doc\prt\1111111Zoom20.prn . Total Time Taken = 10308 milliseconds . source size = 26303844 byte  target file size = 105086184 
test 单线程
D:\doc\prt\1111111Zoom05.prn . Total Time Taken = 1926 milliseconds . source size = 26303844 byte . target file size = 6574596
D:\doc\prt\1111111Zoom08.prn . Total Time Taken = 4626 milliseconds . source size = 26303844 byte . target file size = 16813860
D:\doc\prt\1111111Zoom15.prn . Total Time Taken = 16128 milliseconds . source size = 26303844 byte . target file size = 59082562
D:\doc\prt\1111111Zoom20.prn . Total Time Taken = 28593 milliseconds . source size = 26303844 byte . target file size = 105086184
	         
 */
蜉蝣之翼❉
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Winform(C#) 图片的放大、缩小、打印和导出
08-02
示例很简单，只包含图片的放大、缩小、打印和导出功能
打印到文件prn文件打印软件prf32-216.zip
02-15
打印到文件prn文件打印软件prf32-216.zip
C#打印缩放
pcjiushizhu的专栏
12-20 1746
//如果打印区域宽度大于纸张，进行缩放 int pWidth = m_pd.DefaultPageSettings.Bounds.Width; int pHeight = m_pd.DefaultPageSettings.Bounds.Height; g.DrawImage(m_displayArea, new System.Drawing.Rectangle(0, 0, pWidth, pHei
图像处理RIP软件，图像色彩管理，数字喷墨打印技术
igood99的博客
04-24 4041
数字喷墨打印技术，图像处理RIP软件，图像色彩管理
妙用PRN文件，实现文档换机打印
a19576的专栏
07-29 3637
http://xbeta.info/%E5%A6%99%E7%94%A8prn%E6%96%87%E4%BB%B6%EF%BC%8C%E5%AE%9E%E7%8E%B0%E6%96%87%E6%A1%A3%E6%8D%A2%E6%9C%BA%E6%89%93%E5%8D%B0.htm 你是否曾有如此困扰？想将甲电脑制作的文件拿到乙电脑列印，但问题是乙电脑无法开启该档，或缺乏所需字型，偏偏又不
金属打印版本.prt
12-06
金属打印版本.prt
PROE相关的prt文件
12-20
标题中的“PROE相关的prt文件”指的是Pro/Engineer（现称为Creo Parametric）软件创建的零件模型文件。Pro/Engineer是一款由美国PTC公司开发的参数化三维建模软件，广泛应用于机械工程、汽车制造、航空航天等领域。...
prt.rar_project_prt
09-23
【标题】"prt.rar_project_prt" 暗示这是一个与项目相关的压缩文件，其中可能包含了一系列用于项目开发、设计或管理的文件。"PRT"可能是项目、部分或者特定工具的缩写，但没有具体信息无法确定。该文件可能是一个...
蜘蛛prt格式3D图.prt
04-09
蜘蛛3D图档 蜘蛛3D图档 蜘蛛3D图档 蜘蛛3D图档 蜘蛛3D图档 蜘蛛3D图档 蜘蛛3D图档11111111111111111111111111111111111111111
打印PRN后缀程序
12-15
打印PRN后缀程序，方便的打印PRN后缀程序，很好用，打印保存到文档的好助手！
把prn文件输出到网络打印机
brookmill的专栏
09-10 2743
在dos下运行 type file.prn > \\server_name\printer_name
linux重定向匹配符文件夹,Linux教程之文件描述符、重定向、管道符、tee命令
weixin_34697150的博客
04-29 162
本节讨论一下几个问题：1. 文件描述符。2. 重定向。3. 管道符4. tee的用法。1. 文件描述符。在Linux系统中一切皆文件。文件夹和设备都是文件。如何用来区别不同的文件呢？这里的区别不是我们在Windows下看到的后缀名不同来区别。也不是我们在Linux下用ls 命令看到的不同文件的列表。这里的文件描述符主要讨论的是对文件操作的一个标识符。无操作就无标识符。比如两个进程同时在对同一个文...
Fineui.C#中利用LODOP打印条形码，利用数据库存放打印格式
abc32644的博客
07-30 708
三、页面端JS代码，p1名称，P2条码，打印时调用prn(p1,p2)实现打印，lodoptextID值为传入的打印格式，数据库中Label_Template表中字段LODOP_TEXT的值传入。最近接触LODOP，尝试多种方式保存打印格式，方便调用，思路利用LODOP生成打印代码主要用于调整位置，保存格式到数据库中，打印时调用保存的格式进行打印。黑色加粗部分，代表传入的参数，具体参考LODOP官网说明，利用这些可以方便的实现更多参数的传入，实现套打，设计期利用LODOP的功能实现位置的定位。...
prn文件相关
最新发布
lan_4的博客
07-23 472
Acrobat Distiller是Adobe开发的一款将Postscript文件转换为PDF文件的高端PDF文件生成器，通过OLE(对象链接和嵌入)或Postscript命令来控制。Acrobat Distiller制作的PDF文件保留了源文件中全部内容，包括其中的格式、图形和影像。如果将其勾√选，并且按了确定按钮，那么，得到一个后缀名称为prn的打印文件，我现在需要将他转化为word或者pdf发给别人。最后由于时间关系，选择了用prn文件打印然后扫描的办法。特殊文件格式的转化问题。
C# winform 打印窗体内控件（以图片缩放的形式），核心部分代码
weixin_30847865的博客
04-20 613
using System.Drawing;using System.Drawing.Drawing2D;using System.Drawing.Printing; int currentY = 0; private void PrintDocument1_PrintPage(object sender, System.Drawing.Printing.PrintPageEventA...
在C#中用一个按钮控制斑马zebra条码打印机进行打印
HEIMENGER的博客
09-07 8151
C#Winform控制斑马打印机打印条码标签 前言 这两天在做一个用C#控制斑马标签打码机进行打印条码。 首先打印机选型为 Zebra GT820这个型号 接着在官网上查询相关驱动和Designer设计器 上方为驱动，下方为设计器 ...
C#打印页面设置(横向,页宽,页高)
june905206961的专栏
02-15 2774
c#打印时页面设置 using Excel = Microsoft.Office.Interop.Excel; Excel.Application tmpExcel = new Excel.ApplicationClass(); Excel.Workbook tmpbook = tmpExcel.Workbooks.Open(tmppath, Type.Missing, Type.Missing,...
c++实现prt文件转为bmp文件
04-20
可以使用C语言的图像处理库实现prt文件转为bmp文件，比如OpenCV、ImageMagick等等。其中OpenCV是一个非常受欢迎的图像处理库，可以在官网上下载并安装。具体实现可以参考OpenCV官方文档中的相关部分。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值