Android 使用OpenGLES + MediaPlayer 获取视频截图

在这里插入图片描述

概述

    Android 获取视频缩略图的方法通常有:

  1. ContentResolver: 使用系统数据库
  2. MediaMetadataRetriever: 这个是android提供的类，用来获取本地和网络media相关文件的信息
  3. ThumbnailUtils: 是在android2.2（api8）之后新增的一个，该类为我们提供了三个静态方法供我们使用。
  4. MediaExtractor 与MediaMetadataRetriever类似
    然而, 这几种方法存在一定的局限性, 比如, ContentResolver需要视频文件已经通过mediascanner 添加到系统数据库中, 使用MediaMetadataRetriever不支持某些格式等等. 常规的格式比如MP4, MKV, 这些接口还是很实用的.

    对于系统不支持的播放的格式比如AVI等, 需要一个更丰富的接口或方法来获取视频的缩略图. 于是尝试使用OpenGLES 离屏渲染 + MediaPlayer来提取视频画面作为缩略图.

参考代码

参考:ExtractMpegFramesTest.java 改动, 使用MediaPlayer, 理论上, 只要使用MediaPlayer可以播放的视频, 都可以提取出视频画面.


import android.annotation.SuppressLint;
import android.graphics.Bitmap;
import android.graphics.SurfaceTexture;
import android.media.MediaPlayer;
import android.opengl.EGL14;
import android.opengl.EGLConfig;
import android.opengl.EGLContext;
import android.opengl.EGLDisplay;
import android.opengl.EGLSurface;
import android.opengl.GLES10;
import android.opengl.GLES11Ext;
import android.opengl.GLES20;
import android.os.Build;
import android.util.Log;
import android.view.Surface;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;

import javax.microedition.khronos.opengles.GL10;

public class VideoFrameExtractorGL extends Thread implements MediaPlayer.OnSeekCompleteListener {
	final String TAG = "VFEGL";
	private MediaPlayer mediaPlayer;
	private Surface surface;
	private int bitmapWidth, bitmapHeight;

	private int textureId;
	private SurfaceTexture surfaceTexture;

	final Object drawLock = new Object();

	// Shader代码
	private String vertexShaderCode =
			"#version 300 es\n" +
					"in vec4 position;\n" +
					"in vec2 texCoord;\n" +
					"uniform mat4 uSTMatrix;\n" +
					"out vec2 vTexCoord;\n" +
					"\n" +
					"void main() {\n" +
					"    // \n" +
					"    float curvature = -0.5; // 曲率值，负值表示凹面\n" +
					"    vec4 pos = position;\n" +
					"    //pos.z = curvature * (pos.x * pos.x + pos.y * pos.y);\n" +
					"\n" +
					"    //if(pos.x > 0.0001) pos.y += 0.2;\n" +
					"\n" +
					"    gl_Position = pos;\n" +
					"    vTexCoord = (uSTMatrix * vec4(texCoord, 0.0, 1.0)).xy;\n" +
					"}";

	private String fragmentShaderCode =
			"#version 300 es\n" +
					"#extension GL_OES_EGL_image_external : require\n" +
					"precision mediump float;\n" +
					"\n" +
					"in vec2 vTexCoord;\n" +
					"uniform samplerExternalOES sTexture;\n" +
					"out vec4 fragColor;\n" +
					"\n" +
					"void main() {\n" +
					"    fragColor = texture(sTexture, vTexCoord);\n" +
					"}\n";

	protected float[] mSTMatrix = new float[16];
	protected int mProgram;
	private int mPositionHandle;
	private int mTexCoordHandle;
	private int mSTMatrixHandle;

	// 顶点坐标和纹理坐标
	private final float[] squareCoords = {
			-1.0f,  1.0f,   // top left
			1.0f,  1.0f,   // top right
			-1.0f, -1.0f,   // bottom left
			1.0f, -1.0f    // bottom right
	};

	private final float[] textureCoords = {
			0.0f, 0.0f,   // top left
			1.0f, 0.0f,   // top right
			0.0f, 1.0f,   // bottom left
			1.0f, 1.0f    // bottom right
	};

	private FloatBuffer vertexBuffer;
	private FloatBuffer textureBuffer;


	// EGL相关变量
	private EGLDisplay eglDisplay;
	private EGLContext eglContext;
	private EGLSurface eglSurface;

	boolean isPrepared = false;
	long videoDuration = 0;
	int videoWidth, videoHeight;
	String mPath;

	// 构造函数，初始化MediaPlayer并设置渲染大小
	public VideoFrameExtractorGL(String videoFile, int bitmapWidth, int bitmapHeight, OnFrameExtractListener l) {
		this.bitmapWidth = bitmapWidth;
		this.bitmapHeight = bitmapHeight;
		mPath = videoFile;
		setOnFrameExtractListener(l);
	}

	@Override
	public void run() {
		mediaPlayer = new MediaPlayer();
		mediaPlayer.setVolume(0, 0);
		mediaPlayer.setOnSeekCompleteListener(this);

		initializeEGL();   // 初始化EGL环境
		initializeOpenGL(); // 初始化OpenGL离屏渲染环境
		try {
			mediaPlayer.setDataSource(mPath);
			mediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
				@Override
				public void onPrepared(MediaPlayer mediaPlayer) {
					Log.d(TAG, "onPrepared start playing");
					isPrepared = true;
					videoDuration = mediaPlayer.getDuration();
					videoWidth = mediaPlayer.getVideoWidth();
					videoHeight = mediaPlayer.getVideoHeight();
					mediaPlayer.start();
				}
			});
			mediaPlayer.prepareAsync();

		} catch (Exception e) {
			e.printStackTrace();
		}

		int timeout = 20;
		while(!isPrepared){
			try {
				sleep(30);
				timeout--;
				if(timeout < 0){
					break;
				}
			} catch (InterruptedException ignore) {}
		}

		while(mediaPlayer != null) {
			drawFrameLoop();
		}
	}

	// 初始化EGL环境
	@SuppressLint("NewApi")
	private void initializeEGL() {
		Log.d(TAG, "initializeEGL");
		// 1. 获取默认的EGL显示设备
		eglDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
		if (eglDisplay == EGL14.EGL_NO_DISPLAY) {
			throw new RuntimeException("Unable to get EGL14 display");
		}

		// 2. 初始化EGL
		int[] version = new int[2];
		if (!EGL14.eglInitialize(eglDisplay, version, 0, version, 1)) {
			throw new RuntimeException("Unable to initialize EGL14");
		}

		// 3. 配置EGL
		int[] configAttributes = {
				EGL14.EGL_RED_SIZE, 8,
				EGL14.EGL_GREEN_SIZE, 8,
				EGL14.EGL_BLUE_SIZE, 8,
				EGL14.EGL_ALPHA_SIZE, 8,
				EGL14.EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT,
				EGL14.EGL_NONE
		};
		EGLConfig[] eglConfigs = new EGLConfig[1];
		int[] numConfigs = new int[1];
		EGL14.eglChooseConfig(eglDisplay, configAttributes, 0, eglConfigs, 0, 1, numConfigs, 0);
		if (numConfigs[0] == 0) {
			throw new IllegalArgumentException("No matching EGL configs");
		}
		EGLConfig eglConfig = eglConfigs[0];

		// 4. 创建EGL上下文
		int[] contextAttributes = {
				EGL14.EGL_CONTEXT_CLIENT_VERSION, 2,
				EGL14.EGL_NONE
		};
		eglContext = EGL14.eglCreateContext(eglDisplay, eglConfig, EGL14.EGL_NO_CONTEXT, contextAttributes, 0);
		if (eglContext == null) {
			throw new RuntimeException("Failed to create EGL context");
		}

		// 5. 创建离屏渲染的EGL Surface
		int[] surfaceAttributes = {
				EGL14.EGL_WIDTH, bitmapWidth,
				EGL14.EGL_HEIGHT, bitmapHeight,
				EGL14.EGL_NONE
		};
		eglSurface = EGL14.eglCreatePbufferSurface(eglDisplay, eglConfig, surfaceAttributes, 0);
		if (eglSurface == null) {
			throw new RuntimeException("Failed to create EGL Surface");
		}

		// 6. 绑定上下文
		if (!EGL14.eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext)) {
			throw new RuntimeException("Failed to bind EGL context");
		}
	}

	// 初始化OpenGL ES的离屏渲染，使用帧缓冲区
	private void initializeOpenGL() {
		Log.d(TAG, "initializeOpenGL");
		// 创建纹理并绑定
		int[] textureIds = new int[1];
		GLES20.glGenTextures(1, textureIds, 0);
		textureId = textureIds[0];
		// 绑定纹理并绘制
		//GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
		GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, textureId);
		GLES20.glTexParameterf(
				GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MIN_FILTER,
				GLES20.GL_NEAREST
		);
		GLES20.glTexParameterf(
				GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MAG_FILTER,
				GLES20.GL_LINEAR
		);
		GLES20.glTexParameteri(
				GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_S,
				GLES20.GL_CLAMP_TO_EDGE
		);
		GLES20.glTexParameteri(
				GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_T,
				GLES20.GL_CLAMP_TO_EDGE
		);

		surfaceTexture = new SurfaceTexture(textureId);
		surfaceTexture.setOnFrameAvailableListener(new SurfaceTexture.OnFrameAvailableListener() {
			@Override
			public void onFrameAvailable(SurfaceTexture surfaceTexture) {
				Log.d(TAG, "onFrameAvailable");
				synchronized (drawLock){
					drawLock.notifyAll();
				}
			}
		});
		// 创建Surface与MediaPlayer绑定
		surface = new Surface(surfaceTexture);
		mediaPlayer.setSurface(surface);

		// 初始化着色器
		createProgram(vertexShaderCode, fragmentShaderCode);

		// 在构造函数中初始化缓冲区
		vertexBuffer = ByteBuffer.allocateDirect(squareCoords.length * 4)
				.order(ByteOrder.nativeOrder())
				.asFloatBuffer()
				.put(squareCoords);
		vertexBuffer.position(0);

		textureBuffer = ByteBuffer.allocateDirect(textureCoords.length * 4)
				.order(ByteOrder.nativeOrder())
				.asFloatBuffer()
				.put(textureCoords);
		textureBuffer.position(0);
	}

	// 创建着色器程序
	private void createProgram(String vertexSource, String fragmentSource) {
		int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
		int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
		mProgram = GLES20.glCreateProgram();
		GLES20.glAttachShader(mProgram, vertexShader);
		GLES20.glAttachShader(mProgram, fragmentShader);
		GLES20.glLinkProgram(mProgram);
		GLES20.glUseProgram(mProgram);
		mPositionHandle = GLES20.glGetAttribLocation(mProgram, "position");
		mTexCoordHandle = GLES20.glGetAttribLocation(mProgram, "texCoord");
		mSTMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uSTMatrix");
	}

	// 加载着色器
	private int loadShader(int type, String shaderSource) {
		int shader = GLES20.glCreateShader(type);
		GLES20.glShaderSource(shader, shaderSource);
		GLES20.glCompileShader(shader);
		return shader;
	}

	final Object extractLock = new Object();
	int targetPosOfVideo;
	boolean seeking = false;
	//if ignore time check, add extracting to check if notify callback
	//or else, it will notify after player is started.
	boolean extracting = false;
	@SuppressLint("WrongConstant")
	public void extract(int posOfVideoInMs){
		synchronized (extractLock) {
			targetPosOfVideo = posOfVideoInMs;
			seeking = true;
			extracting = true;
			while (!isPrepared) {
				Log.w(TAG, "extract " + posOfVideoInMs + " ms failed: MediaPlayer is not ready.");
				try {
					Thread.sleep(15);
				} catch (InterruptedException ignore) {}
			}

			{
				if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
					mediaPlayer.seekTo(posOfVideoInMs, MediaPlayer.SEEK_NEXT_SYNC);
				}else{
					mediaPlayer.seekTo(posOfVideoInMs);
				}
			}
			try {
				Log.d(TAG, "extract " + posOfVideoInMs + " ms, and start extractLock wait");
				extractLock.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	public void extract(float posRatio){
		while(!isPrepared){
			try {
				sleep(10);
			} catch (InterruptedException e) {
				throw new RuntimeException(e);
			}
		}
		int pos = (int)(posRatio * videoDuration);
		extract(pos);
	}
	// 截取指定时间的图像帧
	private void drawFrameLoop() {
		synchronized (drawLock) {
			long pos = mediaPlayer.getCurrentPosition();
			Log.d(TAG, "drawFrameLoop at " + pos  + " ms");
            surfaceTexture.updateTexImage();
			surfaceTexture.getTransformMatrix(mSTMatrix);

			GLES20.glViewport(0, 0, bitmapWidth, bitmapHeight);
			GLES10.glClearColor(color[0], color[1], color[2], 1.0f); // 设置背景颜色为黑色
			GLES10.glClear(GL10.GL_COLOR_BUFFER_BIT); // 清除颜色缓冲区

			GLES20.glUseProgram(mProgram);
			// 传递顶点数据
			vertexBuffer.position(0);
			GLES20.glEnableVertexAttribArray(mPositionHandle);
			GLES20.glVertexAttribPointer(mPositionHandle, 2, GLES20.GL_FLOAT, false, 0, vertexBuffer);

			// 传递纹理坐标数据
			textureBuffer.position(0);
			GLES20.glEnableVertexAttribArray(mTexCoordHandle);
			GLES20.glVertexAttribPointer(mTexCoordHandle, 2, GLES20.GL_FLOAT, false, 0, textureBuffer);

			// 传递纹理矩阵
			GLES20.glUniformMatrix4fv(mSTMatrixHandle, 1, false, mSTMatrix, 0);
			// 绘制纹理
			GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, vertexBuffer.limit() / 2);
			Bitmap bm = toBitmap();
			if(extracting && !seeking) {
				boolean notifyCallback = ignoreTimeCheck || (targetPosOfVideo > 0 && pos >= targetPosOfVideo);
				if(notifyCallback) {
					targetPosOfVideo = 0;
					if (oel != null) oel.onFrameExtract(this, bm);
					synchronized (extractLock) {
						Log.d(TAG, "drawFrameLoop notify extractLock");
						extractLock.notify();
					}
				}
			}
			try{drawLock.wait();}catch(Exception ignore){}
        }
	}

	public boolean isDone(){
		return mediaPlayer != null && targetPosOfVideo <= mediaPlayer.getCurrentPosition();
	}

	public Bitmap getBitmap(){
		return toBitmap();
	}

	IntBuffer pixelBuffer;
	private Bitmap toBitmap(){
		// 读取帧缓冲区中的像素
		if(pixelBuffer == null){
			pixelBuffer = IntBuffer.allocate(bitmapWidth * bitmapHeight);
		}else {
			pixelBuffer.rewind();
		}

        GLES20.glReadPixels(0, 0, bitmapWidth, bitmapHeight, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, pixelBuffer);
		// 创建Bitmap并将像素数据写入
		Bitmap bitmap = Bitmap.createBitmap(bitmapWidth, bitmapHeight, Bitmap.Config.ARGB_8888);
        pixelBuffer.position(0);
		bitmap.copyPixelsFromBuffer(pixelBuffer);
        return bitmap;
	}

	// 释放资源
	@SuppressLint("NewApi")
	public void release() {
		if (mediaPlayer != null) {
			mediaPlayer.release();
		}
		mediaPlayer = null;
		synchronized (drawLock){
            try {
                drawLock.wait(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            drawLock.notifyAll();
		}
		if (surface != null) {
			surface.release();
		}
		if (eglSurface != null) {
			EGL14.eglDestroySurface(eglDisplay, eglSurface);
		}
		if (eglContext != null) {
			EGL14.eglDestroyContext(eglDisplay, eglContext);
		}
		if (eglDisplay != null) {
			EGL14.eglTerminate(eglDisplay);
		}
		GLES20.glDeleteTextures(1, new int[]{textureId}, 0);
	}

	float[] color = {0, 0, 0, 1f};
	public void setColor(float r, float g, float b){
		color[0] = r; color[1] = g; color[2] = b;
	}

	OnFrameExtractListener oel;
	public void setOnFrameExtractListener(OnFrameExtractListener l){
		oel = l;
	}

	@Override
	public void onSeekComplete(MediaPlayer mediaPlayer) {
		Log.d(TAG, "onSeekComplete pos=" + mediaPlayer.getCurrentPosition());
		seeking = false;
	}

	public interface OnFrameExtractListener{
		void onFrameExtract(VideoFrameExtractorGL vfe, Bitmap bm);
	}

	public static Bitmap[] extractBitmaps(int[] targetMs, String path, int bmw, int bmh){
		final int len = targetMs.length;
		final Bitmap[] bms = new Bitmap[len];
		VideoFrameExtractorGL vfe = new VideoFrameExtractorGL(path, bmw, bmh, new OnFrameExtractListener() {
			int count = 0;
			@Override
			public void onFrameExtract(VideoFrameExtractorGL vfe, Bitmap bm) {
				Log.d("VFEGL", "extractBitmaps");
				bms[count] = bm;
				count ++;
				if(count >= len){
					vfe.release();
				}
			}
		});
		vfe.start();
		for(int pos : targetMs){
			vfe.extract(pos);
		}

		Log.d("VFEGL", "extractBitmaps done");

		return bms;
	}

	boolean ignoreTimeCheck = false;
	public static Bitmap[] extractBitmaps(String path, int bmw, int bmh,
										  final float durationRatio, final int bitmapCount){
		final Bitmap[] bms = new Bitmap[bitmapCount];
		VideoFrameExtractorGL vfe = new VideoFrameExtractorGL(path, bmw, bmh, new OnFrameExtractListener() {
			int count = 0;
			@Override
			public void onFrameExtract(VideoFrameExtractorGL vfe, Bitmap bm) {
				Log.d("VFEGL", "extractBitmaps");
				bms[count] = bm;
				count ++;
				if(count >= bitmapCount){
					vfe.release();
				}
			}
		});
		vfe.start();
		vfe.ignoreTimeCheck = true;
		vfe.extract(durationRatio);

		Log.d("VFEGL", "extractBitmaps done");

		return bms;
	}
}

基本的流程如下:

  1. 初始化MeidaPlayer 用与播放视频
  2. 初始化OpenGL环境, 绑定Texture 和 SurfaceTexture
  3. 使用SurfaceTexutre创建Surface, 并为MediaPlayer 设置Surface, 这样视频就会绘制到Surface上
  4. 通过SurfaceTexture的setOnFrameAvailableListener回调绘制帧数据
  5. 从OpenGL中提取出glReadPixels提取出像素数据, 填充到Bitmap

调用

		Bitmap[] bms = VideoFrameExtractorGL.extractBitmaps(path, 128, 72, 0.5f, bmCount);

需注意:

  1. 注意OpenGLES 的版本, 1.x 不支持离屏渲染, 2.x 需要配合着色器渲染图像
  2. 构建OpenGL的环境和渲染的工作, 要放在同一个线程中.

参考

Kotlin拿Android本地视频缩略图
Android视频图片缩略图的获取
Android 获取视频缩略图(获取视频每帧数据)的优化方案
37.4 OpenGL离屏渲染环境配置
ExtractMpegFramesTest.java

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/928311.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

面向对象(二)——类和对象(上)

面向对象(二)——类和对象(上)

1 类的定义 做了关于对象的很多介绍&#xff0c;终于进入代码编写阶段。 本节中重点介绍类和对象的基本定义&#xff0c;属性和方法的基本使用方式。 【示例】类的定义方式 // 每一个源文件必须有且只有一个public class&#xff0c;并且类名和文件名保持一致&#xff01; …
阅读更多...
echarts的双X轴，父级居中的相关配置

echarts的双X轴，父级居中的相关配置

前言&#xff1a;折腾了一个星期&#xff0c;在最后一天中午&#xff0c;都快要放弃了&#xff0c;后来坚持下来&#xff0c;才有下面结果。 这个效果就相当是复合表头&#xff0c;第一行是子级&#xff0c;第二行是父级。 子级是奇数个时&#xff0c;父级label居中很简单&…
阅读更多...
顶刊算法 | 鱼鹰算法OOA-BiTCN-BiGRU-Attention多输入单输出回归预测（Maltab）

顶刊算法 | 鱼鹰算法OOA-BiTCN-BiGRU-Attention多输入单输出回归预测（Maltab）

顶刊算法 | 鱼鹰算法OOA-BiTCN-BiGRU-Attention多输入单输出回归预测&#xff08;Maltab&#xff09; 目录 顶刊算法 | 鱼鹰算法OOA-BiTCN-BiGRU-Attention多输入单输出回归预测&#xff08;Maltab&#xff09;效果一览基本介绍程序设计参考资料 效果一览 基本介绍 1.Matlab实…
阅读更多...
Agile VMO分享：海尔案例

Agile VMO分享：海尔案例

海尔集团是全球最大的家电制造商之一&#xff0c;拥有超过76 000名员工。它获得了2018-2019年全球智能家电品牌前10名和2018-2019年全球消费电子品牌前50名的荣誉。 海尔利用价值流结构将自己组织成一些可以自管理的微型企业。这些微型企业拥有决策&#xff0c;设计和交付新产品…
阅读更多...
第七课 Unity编辑器创建的资源优化_UI篇（UGUI）

第七课 Unity编辑器创建的资源优化_UI篇（UGUI）

上期我们学习了简单的Scene优化&#xff0c;接下来我们继续编辑器创建资源的UGUI优化 UI篇&#xff08;UGUI&#xff09; 优化UGUI应从哪些方面入手&#xff1f; 可以从CPU和GPU两方面考虑&#xff0c;CPU方面&#xff0c;避免触发或减少Canvas的Rebuild和Rebatch&#xff0c…
阅读更多...
LabVIEW MathScript工具包对运行速度的影响及优化方法

LabVIEW MathScript工具包对运行速度的影响及优化方法

LabVIEW 的 MathScript 工具包 在运行时可能会影响程序的运行速度&#xff0c;主要是由于以下几个原因&#xff1a; 1. 解释型语言执行方式 MathScript 使用的是类似于 MATLAB 的解释型语言&#xff0c;这意味着它不像编译型语言&#xff08;如 C、C 或 LabVIEW 本身的 VI&…
阅读更多...
中国移动量子云平台：算力并网590量子比特！

中国移动量子云平台：算力并网590量子比特！

在技术革新的浪潮中&#xff0c;量子计算以其独特的并行处理能力和指数级增长的计算潜力&#xff0c;有望成为未来技术范式变革和颠覆式创新应用的新源泉。中国移动作为通信行业的领军企业&#xff0c;致力于量子计算技术研究&#xff0c;推动量子计算产业的跨越式发展。 量子云…
阅读更多...
pytest（二）excel数据驱动

pytest（二）excel数据驱动

一、excel数据驱动 excel文件内容 excel数据驱动使用方法 import openpyxl import pytestdef get_excel():excel_obj openpyxl.load_workbook("../pytest结合数据驱动-excel/data.xlsx")sheet_obj excel_obj["Sheet1"]values sheet_obj.valuescase_li…
阅读更多...
文库 | 从嬴图的技术文档聊起

文库 | 从嬴图的技术文档聊起

在技术的浩瀚海洋中&#xff0c;一份优秀的技术文档宛如精准的航海图。它是知识传承的载体&#xff0c;是团队协作的桥梁&#xff0c;更是产品成功的幕后英雄。然而&#xff0c;打造这样一份出色的技术文档并非易事。你是否在为如何清晰阐释复杂技术而苦恼&#xff1f;是否纠结…
阅读更多...
flask的第一个应用

flask的第一个应用

本文编写一个简单的实例来记录下flask的使用 文章目录 简单实例flask中的路由无参形式有参形式 参数类型本文小结 简单实例 flask的依赖包都安装好之后&#xff0c;我们就可以写一个最简单的web应用程序了&#xff0c;我们把这个应用程序命名为first.py: from flask import Fla…
阅读更多...
【UE5 C++】判断两点连线是否穿过球体

【UE5 C++】判断两点连线是否穿过球体

目录 前言 方法一 原理 代码 测试 结果 方法二 原理 一、检查连线与球体的相交情况 二、检查距离与球体半径的关系 三、检查连线与球体的相交 代码 前言 通过数学原理判断空间中任意两点的连线是否穿过球体&#xff0c;再通过射线检测检验算法的正确性。 方法一 …
阅读更多...
Python办公——openpyxl处理Excel每个sheet每行 修改为软雅黑9号剧中+边框线

Python办公——openpyxl处理Excel每个sheet每行 修改为软雅黑9号剧中+边框线

目录 专栏导读背景1、库的介绍①&#xff1a;openpyxl 2、库的安装3、核心代码4、完整代码5、最快的方法(50万行44秒)——表头其余单元格都修改样式总结 专栏导读 &#x1f338; 欢迎来到Python办公自动化专栏—Python处理办公问题&#xff0c;解放您的双手 &#x1f3f3;️‍…
阅读更多...
Figma入门-约束与对齐

Figma入门-约束与对齐

Figma入门-约束与对齐 前言 在之前的工作中&#xff0c;大家的原型图都是使用 Axure 制作的&#xff0c;印象中 Figma 一直是个专业设计软件。 最近&#xff0c;很多产品朋友告诉我&#xff0c;很多原型图都开始用Figma制作了&#xff0c;并且很多组件都是内置的&#xff0c…
阅读更多...
8. Debian系统中显示屏免密码自动登录

8. Debian系统中显示屏免密码自动登录

本文介绍如何在Debian系统上&#xff0c;启动后&#xff0c;自动免密登录&#xff0c;不卡在登录界面。 1. 修改lightDM配置文件 嵌入式Debian系统采用lightDM显示管理器&#xff0c;所以&#xff0c;一般需要修改它的配置文件/etc/lightdm/lightdm.conf&#xff0c;找到[Seat…
阅读更多...
Unity类银河战士恶魔城学习总结（P156 Audio Settings音频设置）

Unity类银河战士恶魔城学习总结（P156 Audio Settings音频设置）

【Unity教程】从0编程制作类银河恶魔城游戏_哔哩哔哩_bilibili 教程源地址&#xff1a;https://www.udemy.com/course/2d-rpg-alexdev/ 本章节实现了音频的大小设置与保存加载 音频管理器 UI_VolumeSlider.cs 定义了 UI_VolumeSlider 类&#xff0c;用于处理与音频设置相关的…
阅读更多...
控制访问权限

控制访问权限

Swift中的控制访问权限有5种&#xff0c;分别是private&#xff0c;fileprivate&#xff0c;public&#xff0c;open&#xff0c;intelnal。 如果我们没有写访问权限关键字时&#xff0c;默认的访问权限是intelnal 访问控制权限从高到低的顺序是&#xff1a;open > public…
阅读更多...
单例模式的析构学习

单例模式的析构学习

1、例子 如果单例对象是类的static成员&#xff0c;那么在程序结束时不会调用类的析构函数&#xff0c;如下&#xff1a; #include <iostream> using namespace std;class A{ private:static A* m_ins;//声明&#xff0c;静态指针成员A(){} public:static A* getIns(){…
阅读更多...
Function Arguments and Function Parameters (函数的实参和函数的形参)

Function Arguments and Function Parameters (函数的实参和函数的形参)

Function Arguments and Function Parameters {函数的实参和函数的形参} 1. Object-Oriented Programming Using C2. Function Arguments and Function ParametersReferences 1. Object-Oriented Programming Using C https://icarus.cs.weber.edu/~dab/cs1410/textbook/index…
阅读更多...
[SWPUCTF 2021 新生赛]gif好像有点大

[SWPUCTF 2021 新生赛]gif好像有点大

[SWPUCTF 2021 新生赛]gif好像有点大 帧解一下 找到这个二维码用软件CQR解开一下 得到flag NSSCTF{The_G1F_ls_T00_b1g} [BJDCTF 2020]base?? 给了我们base64加密的密文 用python直接解密 import base64 dict{0: J, 1: K, 2: L, 3: M, 4: N, 5: O, 6: x, 7: y, 8: U, 9: …
阅读更多...
嵌入式蓝桥杯学习1 点亮LED

嵌入式蓝桥杯学习1 点亮LED

cubemx配置 1.新建一个STM32G431RBT6文件 2.在System-Core中点击SYS&#xff0c;找到Debug&#xff08;设置为Serial Wire&#xff09; 3.在System-Core中点击RCC&#xff0c;找到High Speed Clock(设置为Crystal/Ceramic Resonator) 4.打开Clock Configuration &#xff0…
阅读更多...
最新文章

Copyright @ 2022~2023