【Filament】绘制圆形

news2024/11/15 13:40:26

1 前言

        Filament环境搭建中介绍了 Filament 的 Windows 和 Android 环境搭，绘制三角形中介绍了绘制纯色和彩色三角形，绘制矩形中介绍了绘制纯色和彩色矩形，本文将使用 Filament 绘制圆形。

2 绘制圆形

        本文项目结构如下，完整代码资源 → Filament绘制圆形。

2.1 自定义基类

        为方便读者将注意力聚焦在 Filament 的输入上，轻松配置复杂的环境依赖逻辑，笔者仿照 OpenGL ES 的写法，抽出了 FLSurfaceView 和 BaseModel 类。FLSurfaceView 与 GLSurfaceView 的功能类似，承载了渲染环境配置；BaseModel 中提供了一些 VertexBuffer、IndexBuffer、Material、Renderable 相关的工具类，方便子类直接使用这些工具类。

        build.gradle

...
android {
    ...
    aaptOptions { // 在应用程序打包过程中不压缩的文件
        noCompress 'filamat', 'ktx'
    }
}
 
dependencies {
    implementation fileTree(dir: '../libs', include: ['*.aar'])
    ...
}

        说明：在项目根目录下的 libs 目录中，需要放入以下 aar 文件，它们源自Filament环境搭建中编译生成的 aar。 

        FLSurfaceView.java

package com.zhyan8.circle.filament;

import android.content.Context;
import android.graphics.Point;
import android.view.Choreographer;
import android.view.Surface;
import android.view.SurfaceView;

import com.google.android.filament.Camera;
import com.google.android.filament.Engine;
import com.google.android.filament.EntityManager;
import com.google.android.filament.Filament;
import com.google.android.filament.Renderer;
import com.google.android.filament.Scene;
import com.google.android.filament.Skybox;
import com.google.android.filament.SwapChain;
import com.google.android.filament.View;
import com.google.android.filament.Viewport;
import com.google.android.filament.android.DisplayHelper;
import com.google.android.filament.android.FilamentHelper;
import com.google.android.filament.android.UiHelper;

/*
 * Filament中待渲染的SurfaceView
 * 功能可以类比OpenGL ES中的GLSurfaceView
 * 用于创建Filament的渲染环境
 */
public class FLSurfaceView extends SurfaceView {
    public static int RENDERMODE_WHEN_DIRTY = 0; // 用户请求渲染才渲染一帧
    public static int RENDERMODE_CONTINUOUSLY = 1; // 持续渲染
    protected int mRenderMode = RENDERMODE_CONTINUOUSLY; // 渲染模式
    protected Choreographer mChoreographer; // 消息控制
    protected DisplayHelper mDisplayHelper; // 管理Display(可以监听分辨率或刷新率的变化)
    protected UiHelper mUiHelper; // 管理SurfaceView、TextureView、SurfaceHolder
    protected Engine mEngine; // 引擎(跟踪用户创建的资源, 管理渲染线程和硬件渲染器)
    protected Renderer mRenderer; // 渲染器(用于操作系统窗口, 生成绘制命令, 管理帧延时)
    protected Scene mScene; // 场景(管理渲染对象、灯光)
    protected View mView; // 存储渲染数据(View是Renderer操作的对象)
    protected Camera mCamera; // 相机(视角管理)
    protected Point mDesiredSize; // 渲染分辨率
    protected float[] mSkyboxColor; // 背景颜色
    protected SwapChain mSwapChain; // 操作系统的本地可渲染表面(native renderable surface, 通常是一个window或view)
    protected FrameCallback mFrameCallback = new FrameCallback(); // 帧回调

    static {
        Filament.init();
    }

    public FLSurfaceView(Context context) {
        super(context);
        mChoreographer = Choreographer.getInstance();
        mDisplayHelper = new DisplayHelper(context);
    }

    public void init() { // 初始化
        setupSurfaceView();
        setupFilament();
        setupView();
        setupScene();
    }

    public void setRenderMode(int renderMode) { // 设置渲染模式
        mRenderMode = renderMode;
    }

    public void requestRender() { // 请求渲染
        mChoreographer.postFrameCallback(mFrameCallback);
    }

    public void onResume() { // 恢复
        mChoreographer.postFrameCallback(mFrameCallback);
    }

    public void onPause() { // 暂停
        mChoreographer.removeFrameCallback(mFrameCallback);
    }

    public void onDestroy() { // 销毁Filament环境
        mChoreographer.removeFrameCallback(mFrameCallback);
        mUiHelper.detach();
        mEngine.destroyRenderer(mRenderer);
        mEngine.destroyView(mView);
        mEngine.destroyScene(mScene);
        mEngine.destroyCameraComponent(mCamera.getEntity());
        EntityManager entityManager = EntityManager.get();
        entityManager.destroy(mCamera.getEntity());
        mEngine.destroy();
    }

    protected void setupScene() { // 设置Scene参数
    }

    protected void onResized(int width, int height) { // Surface尺寸变化时回调
        double zoom = 1;
        double aspect = (double) width / (double) height;
        mCamera.setProjection(Camera.Projection.ORTHO,
                -aspect * zoom, aspect * zoom, -zoom, zoom, 0, 1000);
    }

    private void setupSurfaceView() { // 设置SurfaceView
        mUiHelper = new UiHelper(UiHelper.ContextErrorPolicy.DONT_CHECK);
        mUiHelper.setRenderCallback(new SurfaceCallback());
        if (mDesiredSize != null) {
            mUiHelper.setDesiredSize(mDesiredSize.x, mDesiredSize.y);
        }
        mUiHelper.attachTo(this);
    }

    private void setupFilament() { // 设置Filament参数
        mEngine = Engine.create();
        // mEngine = (new Engine.Builder()).featureLevel(Engine.FeatureLevel.FEATURE_LEVEL_0).build();
        mRenderer = mEngine.createRenderer();
        mScene = mEngine.createScene();
        mView = mEngine.createView();
        mCamera = mEngine.createCamera(mEngine.getEntityManager().create());
    }

    private void setupView() { // 设置View参数
        float[] color = mSkyboxColor != null ? mSkyboxColor : new float[] {0, 0, 0, 1};
        Skybox skybox = (new Skybox.Builder()).color(color).build(mEngine);
        mScene.setSkybox(skybox);
        if (mEngine.getActiveFeatureLevel() == Engine.FeatureLevel.FEATURE_LEVEL_0) {
            mView.setPostProcessingEnabled(false); // FEATURE_LEVEL_0不支持post-processing
        }
        mView.setCamera(mCamera);
        mView.setScene(mScene);
    }

    /*
     * 帧回调
     */
    private class FrameCallback implements Choreographer.FrameCallback {
        @Override
        public void doFrame(long frameTimeNanos) { // 渲染每帧数据
            if (mRenderMode == RENDERMODE_CONTINUOUSLY) {
                mChoreographer.postFrameCallback(this); // 请求下一帧
            }
            if (mUiHelper.isReadyToRender()) {
                if (mRenderer.beginFrame(mSwapChain, frameTimeNanos)) {
                    mRenderer.render(mView);
                    mRenderer.endFrame();
                }
            }
        }
    }

    /*
     * Surface回调
     */
    private class SurfaceCallback implements UiHelper.RendererCallback {
        @Override
        public void onNativeWindowChanged(Surface surface) { // Native窗口改变时回调
            if (mSwapChain != null) {
                mEngine.destroySwapChain(mSwapChain);
            }
            long flags = mUiHelper.getSwapChainFlags();
            if (mEngine.getActiveFeatureLevel() == Engine.FeatureLevel.FEATURE_LEVEL_0) {
                if (SwapChain.isSRGBSwapChainSupported(mEngine)) {
                    flags = flags | SwapChain.CONFIG_SRGB_COLORSPACE;
                }
            }
            mSwapChain = mEngine.createSwapChain(surface, flags);
            mDisplayHelper.attach(mRenderer, getDisplay());
        }

        @Override
        public void onDetachedFromSurface() { // 解绑Surface时回调
            mDisplayHelper.detach();
            if (mSwapChain != null) {
                mEngine.destroySwapChain(mSwapChain);
                mEngine.flushAndWait();
                mSwapChain = null;
            }
        }

        @Override
        public void onResized(int width, int height) { // Surface尺寸变化时回调
            mView.setViewport(new Viewport(0, 0, width, height));
            FilamentHelper.synchronizePendingFrames(mEngine);
            FLSurfaceView.this.onResized(width, height);
        }
    }
}

        BaseModel.java

package com.zhyan8.circle.filament;

import android.content.res.AssetFileDescriptor;
import android.content.res.AssetManager;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;

import com.google.android.filament.Box;
import com.google.android.filament.Engine;
import com.google.android.filament.EntityManager;
import com.google.android.filament.IndexBuffer;
import com.google.android.filament.Material;
import com.google.android.filament.RenderableManager;
import com.google.android.filament.RenderableManager.PrimitiveType;
import com.google.android.filament.VertexBuffer;
import com.google.android.filament.VertexBuffer.AttributeType;
import com.google.android.filament.VertexBuffer.VertexAttribute;

import java.io.FileInputStream;
import java.io.IOException;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;

/*
 * 模型基类
 * 管理模型的材质、顶点属性、顶点索引、渲染id
 */
public class BaseModel {
    private static String TAG = "BaseModel";
    protected AssetManager mAssetManager; // 资源管理器
    protected Engine mEngine; // Filament引擎
    protected Material mMaterial; // 模型材质
    protected VertexBuffer mVertexBuffer; // 顶点属性缓存
    protected IndexBuffer mIndexBuffer; // 顶点索引缓存
    protected int mRenderable; // 渲染id
    protected Box mBox; // 渲染区域

    public BaseModel(AssetManager assetManager, Engine engine) {
        mAssetManager = assetManager;
        mEngine = engine;
    }

    public Material getMaterial() { // 获取材质
        return mMaterial;
    }

    public VertexBuffer getVertexBuffer() { // 获取顶点属性缓存
        return mVertexBuffer;
    }

    public IndexBuffer getIndexBuffer() { // 获取顶点索引缓存
        return mIndexBuffer;
    }

    public int getRenderable() { // 获取渲染id
        return mRenderable;
    }

    public void destroy() { // 销毁模型
        mEngine.destroyEntity(mRenderable);
        mEngine.destroyVertexBuffer(mVertexBuffer);
        mEngine.destroyIndexBuffer(mIndexBuffer);
        mEngine.destroyMaterial(mMaterial);
        EntityManager entityManager = EntityManager.get();
        entityManager.destroy(mRenderable);
    }

    protected Material loadMaterial(String materialPath) { // 加载材质
        Buffer buffer = readUncompressedAsset(mAssetManager, materialPath);
        if (buffer != null) {
            Material material = (new Material.Builder()).payload(buffer, buffer.remaining()).build(mEngine);
            material.compile(
                    Material.CompilerPriorityQueue.HIGH,
                    Material.UserVariantFilterBit.ALL,
                    new Handler(Looper.getMainLooper()),
                    () -> Log.i(TAG, "Material " + material.getName() + " compiled."));
            mEngine.flush();
            return material;
        }
        return null;
    }

    protected VertexBuffer getVertexBuffer(float[] values) { // 获取顶点属性缓存
        ByteBuffer vertexData = getByteBuffer(values);
        int vertexCount = values.length / 3;
        int vertexSize = Float.BYTES * 3;
        VertexBuffer vertexBuffer = new VertexBuffer.Builder()
                .bufferCount(1)
                .vertexCount(vertexCount)
                .attribute(VertexAttribute.POSITION, 0, AttributeType.FLOAT3, 0, vertexSize)
                .build(mEngine);
        vertexBuffer.setBufferAt(mEngine, 0, vertexData);
        return vertexBuffer;
    }

    protected VertexBuffer getVertexBuffer(Vertex[] values) { // 获取顶点属性缓存
        ByteBuffer vertexData = getByteBuffer(values);
        int vertexCount = values.length;
        int vertexSize = Vertex.BYTES;
        VertexBuffer vertexBuffer = new VertexBuffer.Builder()
                .bufferCount(1)
                .vertexCount(vertexCount)
                .attribute(VertexAttribute.POSITION, 0, AttributeType.FLOAT3, 0, vertexSize)
                .attribute(VertexAttribute.COLOR,    0, AttributeType.UBYTE4, 3 * Float.BYTES, vertexSize)
                .normalized(VertexAttribute.COLOR)
                .build(mEngine);
        vertexBuffer.setBufferAt(mEngine, 0, vertexData);
        return vertexBuffer;
    }

    protected IndexBuffer getIndexBuffer(short[] values) { // 获取顶点索引缓存
        ByteBuffer indexData = getByteBuffer(values);
        int indexCount = values.length;
        IndexBuffer indexBuffer = new IndexBuffer.Builder()
                .indexCount(indexCount)
                .bufferType(IndexBuffer.Builder.IndexType.USHORT)
                .build(mEngine);
        indexBuffer.setBuffer(mEngine, indexData);
        return indexBuffer;
    }

    protected int getRenderable(PrimitiveType primitiveType, int vertexCount) { // 获取渲染id
        int renderable = EntityManager.get().create();
        new RenderableManager.Builder(1)
                .boundingBox(mBox)
                .geometry(0, primitiveType, mVertexBuffer, mIndexBuffer, 0, vertexCount)
                .material(0, mMaterial.getDefaultInstance())
                .build(mEngine, renderable);
        return renderable;
    }

    private Buffer readUncompressedAsset(AssetManager assetManager, String assetName) { // 加载资源
        ReadableByteChannel src = null;
        ByteBuffer dist = null;
        try {
            AssetFileDescriptor fd = assetManager.openFd(assetName);
            FileInputStream fis = fd.createInputStream();
            dist = ByteBuffer.allocate((int) fd.getLength());
            src = Channels.newChannel(fis);
            src.read(dist);
        } catch (IOException e) {
            Log.d(TAG, "readUncompressedAsset-catch, e=" + e);
        } finally {
            if (src != null) {
                try {
                    src.close();
                } catch (IOException e) {
                    Log.d(TAG, "readUncompressedAsset-finally, e=" + e);
                }
            }
        }
        if (dist != null) {
            return dist.rewind();
        }
        return null;
    }

    private ByteBuffer getByteBuffer(float[] values) { // float数组转换为ByteBuffer
        ByteBuffer byteBuffer = ByteBuffer.allocate(values.length * Float.BYTES);
        byteBuffer.order(ByteOrder.nativeOrder());
        for (int i = 0; i < values.length; i++) {
            byteBuffer.putFloat(values[i]);
        }
        byteBuffer.flip();
        return byteBuffer;
    }

    private ByteBuffer getByteBuffer(short[] values) { // short数组转换为ByteBuffer
        ByteBuffer byteBuffer = ByteBuffer.allocate(values.length * Short.BYTES);
        byteBuffer.order(ByteOrder.nativeOrder());
        for (int i = 0; i < values.length; i++) {
            byteBuffer.putShort(values[i]);
        }
        byteBuffer.flip();
        return byteBuffer;
    }

    private ByteBuffer getByteBuffer(Vertex[] values) { // Vertex数组转换为ByteBuffer
        ByteBuffer byteBuffer = ByteBuffer.allocate(values.length * Vertex.BYTES);
        byteBuffer.order(ByteOrder.nativeOrder());
        for (int i = 0; i < values.length; i++) {
            values[i].put(byteBuffer);
        }
        byteBuffer.flip();
        return byteBuffer;
    }

    /*
     * 顶点数据
     * 包含顶点位置和颜色
     */
    public static class Vertex {
        public static int BYTES = 16;
        public float x;
        public float y;
        public float z;
        public int color;
        public Vertex() {}
        public Vertex(float x, float y, float z, int color) {
            this.x = x;
            this.y = y;
            this.z = z;
            this.color = color;
        }

        public ByteBuffer put(ByteBuffer buffer) { // Vertex转换为ByteBuffer
            buffer.putFloat(x);
            buffer.putFloat(y);
            buffer.putFloat(z);
            buffer.putInt(color);
            return buffer;
        }
    }
}

2.2 绘制纯色圆形

        MainActivity.java

package com.zhyan8.circle;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

import com.zhyan8.circle.filament.FLSurfaceView;

public class MainActivity extends AppCompatActivity {
    private FLSurfaceView mFLSurfaceView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mFLSurfaceView = new MyFLSurfaceView(this);
        setContentView(mFLSurfaceView);
        mFLSurfaceView.init();
        mFLSurfaceView.setRenderMode(FLSurfaceView.RENDERMODE_CONTINUOUSLY);
    }

    @Override
    public void onResume() {
        super.onResume();
        mFLSurfaceView.onResume();
    }

    @Override
    public void onPause() {
        super.onPause();
        mFLSurfaceView.onPause();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        mFLSurfaceView.onDestroy();
    }
}

        MyFLSurfaceView.java

package com.zhyan8.circle;

import android.content.Context;

import com.google.android.filament.Camera;
import com.zhyan8.circle.filament.BaseModel;
import com.zhyan8.circle.filament.FLSurfaceView;

public class MyFLSurfaceView extends FLSurfaceView {
    private BaseModel mMyModel;
    public MyFLSurfaceView(Context context) {
        super(context);
    }

    public void init() {
        mSkyboxColor = new float[] {0.965f, 0.941f, 0.887f, 1};
        super.init();
    }

    @Override
    public void onDestroy() {
        mMyModel.destroy();
        super.onDestroy();
    }

    @Override
    protected void setupScene() { // 设置Scene参数
        mMyModel = new Circle(getContext().getAssets(), mEngine);
        mScene.addEntity(mMyModel.getRenderable());
    }

    @Override
    protected void onResized(int width, int height) {
        double zoom = 1.5;
        double aspect = (double) width / (double) height;
        mCamera.setProjection(Camera.Projection.ORTHO,
                -aspect * zoom, aspect * zoom, -zoom, zoom, 0, 10);
    }
}

        Circle.java

package com.zhyan8.circle;

import android.content.res.AssetManager;

import com.google.android.filament.Box;
import com.google.android.filament.Engine;
import com.google.android.filament.RenderableManager.PrimitiveType;
import com.zhyan8.circle.filament.BaseModel;

public class Circle extends BaseModel {
    private String materialPath = "materials/circle.filamat";
    private float[] mVertices;
    private short[] mIndex;

    public Circle(AssetManager assetManager, Engine engine) {
        super(assetManager, engine);
        init();
    }

    private void init() {
        int num = 50;
        mVertices = getCircle(0, 0, 0.5f, num);
        mIndex = getIndices(num);
        mBox = new Box(0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.01f);
        mMaterial = loadMaterial(materialPath);
        mVertexBuffer = getVertexBuffer(mVertices);
        mIndexBuffer = getIndexBuffer(mIndex);
        mRenderable = getRenderable(PrimitiveType.TRIANGLES, mIndex.length);
    }

    private float[] getCircle(float centerX, float centerY, float radius, int num) {
        float unit = (float) (2 * Math.PI / num);
        float[] coords = new float[(num + 1) * 3];
        int index = 0;
        for (int i = 0; i < num; i++) {
            coords[index++] = (float)(centerX + radius * Math.cos(unit * i));
            coords[index++] = (float)(centerY + radius * Math.sin(unit * i));
            coords[index++] = 0;
        }
        coords[index++] = centerX;
        coords[index++] = centerY;
        coords[index] = 0;
        return coords;
    }

    private short[] getIndices(int num) {
        short[] indices = new short[num * 3];
        short centerIndex = (short) num;
        short index = 0;
        for (short i = 0; i < num - 1; i++) {
            indices[index++] = centerIndex;
            indices[index++] = i;
            indices[index++] = (short)(i + 1);
        }
        indices[index++] = centerIndex;
        indices[index++] = (short) (num - 1);
        indices[index] = 0;
        return indices;
    }
}

        circle.mat

material {
    name : circle,

    // 禁用所有lighting
    shadingModel : unlit,
    featureLevel : 0
}

fragment {

    vec3 sRGB_to_linear(vec3 color) { // gamma解码, 转换到线下空间
        color.x = pow(color.r, 2.2);
        color.y = pow(color.g, 2.2);
        color.z = pow(color.b, 2.2);
        return color;
    }

    void material(inout MaterialInputs material) {
        prepareMaterial(material); // 在方法返回前必须回调该函数
        vec3 color = vec3(0.455, 0.725, 1.0);
        color = sRGB_to_linear(color);
        material.baseColor = vec4(color, 1.0);
    }
}

        说明：这里需要进行伽马解码处理，将颜色空间转换到线性空间中，否则显示的颜色将会偏亮，伽马编码原理详见 → 【Unity3D】伽马校正。

        transform.bat

@echo off
setlocal enabledelayedexpansion
set "srcFolder=../src/main/materials"
set "distFolder=../src/main/assets/materials"

for %%f in ("%srcFolder%\*.mat") do (
	set "matfile=%%~nf"
	matc -p mobile -a opengl -o "!matfile!.filamat" "%%f"
    move "!matfile!.filamat" "%distFolder%\!matfile!.filamat"
)

echo Processing complete.
pause

        说明：需要将 matc.exe 文件与 transform.bat 文件放在同一个目录下面，matc.exe 源自Filament环境搭建中编译生成的 exe 文件。双击 transform.bat 文件，会自动将 /src/main/materials/ 下面的所有 mat 文件全部转换为 filamat 文件，并复制到 /src/main/assets/materials/ 文件下面。

        运行效果如下。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Apache Flink（十七）：Flink On Standalone任务提交-Standalone Application模式

Apache Flink（十七）：Flink On Standalone任务提交-Standalone Application模式

🏡 个人主页：IT贫道_大数据OLAP体系技术栈,Apache Doris,Clickhouse 技术-CSDN博客 🚩 私聊博主：加入大数据技术讨论群聊，获取更多大数据资料。 🔔 博主个人B栈地址：豹哥教你大数据的个人空间-豹哥教你大数据个人主页-哔哩哔哩视频 目录
阅读更多...
从零开始的神经网络

从零开始的神经网络

先决条件 在本文中&#xff0c;我将解释如何通过实现前向和后向传递&#xff08;反向传播&#xff09;来构建基本的深度神经网络。这需要一些关于神经网络功能的具体知识。 了解线性代数的基础知识也很重要&#xff0c;这样才能理解我为什么要在本文中执行某些运算。我最好的…
阅读更多...
【FLV】文件解析源码分析：视频解析为可解码的nalu单元

【FLV】文件解析源码分析：视频解析为可解码的nalu单元

https flv 拉到的数据是flv宏观看 ： 每一部分都是 A+ Prev 的模式 A 可以是header ：9个字节可以是TAG ：大小可变而每个TAG 都有个固定的部分： TAG HEADER ，大小9个字节 ，里面是类型、大小、时间戳、扩展时间戳、流ID 因此，可以直接去掉9+4 个字节的第一部分：FLV HEADER…
阅读更多...
凯斯西储大学轴承数据解读

凯斯西储大学轴承数据解读

文章目录 一、凯斯西储大学轴承数据基础知识&#xff1f;1.1 故障种类1.2 故障点尺寸&#xff08;单点故障&#xff09;1.3 载荷和转速 二、数据解读2.1 文件2.2 以12k Drive End Bearing Fault Data为例2.3 以&#xff08;0.007&#xff0c;inner race)为例。 3 Normal Baseli…
阅读更多...
vivado 关于时钟

vivado 关于时钟

关于时钟 在数字设计中&#xff0c;时钟代表了从寄存器可靠传输数据的时间基准注册。AMD Vivado™集成设计环境&#xff08;IDE&#xff09;计时引擎使用时钟计算时序路径要求并通过以下方式报告设计时序裕度的特性松弛计算的方法有关更多信息&#xff0c;请参阅Vivado Design…
阅读更多...
杰发科技AC7840——在Eclipse环境下使用Jlink调试

杰发科技AC7840——在Eclipse环境下使用Jlink调试

序 杰发给的代码里面已经做代码相关配置&#xff0c;搭建好eclipse环境即可运行&#xff0c;搭建步骤还是比较简单的。 参考文章 如何使用Eclipse搭配JLink来调试HelloWold应用程序&#xff1f;-电子发烧友网 软件链接 杰发科技Eclipse的sample代码里面的doc文章&#xff…
阅读更多...
C# .Net学习笔记—— Expression 表达式目录树

C# .Net学习笔记—— Expression 表达式目录树

一、什么是表达式目录树 &#xff08;1&#xff09;Expression我们称为是表达式树&#xff0c;是一种数据结构体&#xff0c;用于存储需要计算&#xff0c;运算的一种结构&#xff0c;这种结构可以只是存储&#xff0c;而不进行运算。通常表达式目录树是配合Lambda一起来使用的…
阅读更多...
关于“Python”的核心知识点整理大全32

关于“Python”的核心知识点整理大全32

目录 12.6.4 调整飞船的速度 settings.py ship.py alien_invasion.py 12.6.5 限制飞船的活动范围 ship.py 12.6.6 重构 check_events() game_functions.py 12.7 简单回顾 12.7.1 alien_invasion.py 12.7.2 settings.py 12.7.3 game_functions.py 12.7.4 ship.py …
阅读更多...
Hive入门＋部署

Hive入门＋部署

看黑马视频做的笔记 目录 概念 1.基本概述 2.基础架构 总架构 部署 1.安装MySQL 2.配置Hadoop 3.下载解压Hive 4.下载MySQL Driver包 注意&#xff01; 5.配置Hive 6.初始化元数据库 7.启动Hive&#xff08;使用Hadoop用户&#xff09; 实例 查看HDFS上表中存…
阅读更多...
网络基础【网线的制作、OSI七层模型、集线器、交换机介绍、路由器的配置】

网络基础【网线的制作、OSI七层模型、集线器、交换机介绍、路由器的配置】

目录 一.网线的制作 1.1.网线的标准 1.2.水晶头的做法 二.OSI七层模型、集线器、交换机介绍 集线器&#xff08;Hub&#xff09;&#xff1a; 交换机&#xff08;Switch&#xff09;&#xff1a; 三.路由器的配置 3.1.使用 3.2.常用的功能介绍 1、如何管理路由器 2、家…
阅读更多...
CW32单片机在智能马桶的应用介绍

CW32单片机在智能马桶的应用介绍

智能科技的迅速发展使得我们的日常生活变得更加便捷和舒适。智能马桶作为其中一种智能家居产品&#xff0c;通过单片机接受和处理来自传感器的数据&#xff0c;然后通过控制模块对智能马桶的各项功能进行控制&#xff0c;实现对智能马桶的全面控制和调节。本文将介绍CW32单片机…
阅读更多...
苹果发布iOS 17.2.1版本更新

苹果发布iOS 17.2.1版本更新

12月20日&#xff0c;苹果向iPhone用户推送了iOS 17.2.1更新。苹果公司在更新日志中称&#xff1a;“本更新包含了重要的错误修复&#xff0c;并解决了某些情况下电池电量较预期更快耗尽的问题。” 据报道&#xff0c;iOS 17系统在发布初期便出现了一系列问题&#xff0c;如发…
阅读更多...
PSP - 结构生物学中的机器学习 (NIPS MLSB Workshop 2023.12)

PSP - 结构生物学中的机器学习 (NIPS MLSB Workshop 2023.12)

欢迎关注我的CSDN&#xff1a;https://spike.blog.csdn.net/ 本文地址&#xff1a;https://spike.blog.csdn.net/article/details/135120094 Machine Learning in Structural Biology (机器学习在结构生物学中) 网址&#xff1a;https://www.mlsb.io/ Workshop at the 37th Co…
阅读更多...
神经科学与计算神经科学的蓬勃发展与未来趋势

神经科学与计算神经科学的蓬勃发展与未来趋势

导言 神经科学和计算神经科学是当前科学研究领域中备受关注的方向。本文将深入研究这两个领域的发展历程、遇到的问题、解决过程&#xff0c;以及未来的可用范围。我们还将关注在各国的应用现状以及未来的研究趋势&#xff0c;探讨如何在竞争中取胜&#xff0c;以及在哪些方面发…
阅读更多...
大数据处理与分析

大数据处理与分析

掌握分布式并行编程框架MapReduce掌握基于内存的分布式计算框架Spark理解MapReduce的工作流程、Spark运行原理熟悉机器学习概念 一.MapReduce Hadoop MapReduce是一个软件框架&#xff0c;基于该框架能够容易地编写应用程序&#xff0c;这些应用程序能够运行在由上千个商用机器…
阅读更多...
机器学习数据的清洗，转化，汇总及建模完整步骤（基于Titanic数据集）

机器学习数据的清洗，转化，汇总及建模完整步骤（基于Titanic数据集）

目录 介绍&#xff1a; 一、数据 二、检查数据缺失 三、数据分析 四、数据清洗 五、数据类别转化 六、数据汇总和整理 七、建模 介绍&#xff1a; 线性回归是一种常用的机器学习方法&#xff0c;用于建立一个输入变量与输出变量之间线性关系的预测模型。线性回归的目标…
阅读更多...
vs code创建工程，以koa框架为例

vs code创建工程，以koa框架为例

以下内容为本人的学习笔记&#xff0c;如需要转载&#xff0c;请声明原文链接 微信公众号「englyf」https://mp.weixin.qq.com/s/x2OXMTaLlxb_Os7NDHrKsg 这里以应用 koa 框架写一个 http 服务器为例&#xff0c;来说明怎么用 vs code 创建工程。 进入 vs code 后&#xff0c…
阅读更多...
云服务器 nginx自启动、mysql自启动、pyhton后端自启动

云服务器 nginx自启动、mysql自启动、pyhton后端自启动

nginx自启动 方法一&#xff1a; 1、建立启动文件 vim /usr/lib/systemd/system/nginx.service [Unit] Descriptionnginx - high performance web server Afternetwork.target remote-fs.target nss-lookup.target[Service] Typeforking ExecStart/usr/local/nginx/sbin/ng…
阅读更多...
DMA实验3-外设到内存搬运

DMA实验3-外设到内存搬运

实验要求 使用 DMA 的方式将串口接收缓存寄存器的值搬运到内存中&#xff0c;同时闪烁 LED1 。 CubeMX 配置 DMA 配置&#xff1a; 串口中断配置 代码实现 如何判断串口接收是否完成&#xff1f;如何知道串口收到数据的长度&#xff1f; 使用串口空闲中断&#xff08;IDL…
阅读更多...
2023优秀开源项目获选榜名单(开放原子开源基金会)｜JeecgBoot 成功入选

2023优秀开源项目获选榜名单(开放原子开源基金会)｜JeecgBoot 成功入选

JeecgBoot 是一个开源的企业级低代码开发平台&#xff0c;它成功入选2023年度生态开源项目&#xff0c;这是对其十年坚持开源的认可。作为一个开源项目&#xff0c;JeecgBoot 在过去的十年里一直秉承着开放、共享、协作的理念&#xff0c;不断推动着开源社区的发展。 2023年开放…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023