【JAVA】OPENGL+TIFF格式图片，不同阈值旋转效果

有些科学研究领域会用到一些TIFF格式图片，由于是多张图片相互渐变，看起来比较有意思：

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.*;

/**
 * 可以自已定义日志打印格式，这样看起来比较方便些
 *
 */
class MyFormatter extends Formatter
{
    @Override
    public String format(LogRecord arg0)
    {
        //创建StringBuilder对象来存放后续需要打印的日志内容
        StringBuilder builder = new StringBuilder();

        //获取时间
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss.SSS");
        Date now = new Date();
        String dateStr = simpleDateFormat.format(now);

        builder.append("[");
        builder.append(dateStr);
        builder.append(" ");

        //拼接日志级别
        builder.append(arg0.getLevel()).append(" ");

        builder.append(arg0.getSourceClassName()).append(" ");

        //拼接方法名
        builder.append(arg0.getSourceMethodName()).append(" ");

        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        String line = stackTrace[8].toString();
        String lineNumber = line.substring(line.indexOf(":") + 1, line.length() - 1);

        //拼接方法名
        builder.append(lineNumber).append("] ");

        //拼接日志内容
        builder.append(arg0.getMessage());

        //日志换行
        builder.append("\r\n");

        return builder.toString();
    }
}

public class MyLogger {
    static Logger logger;

    static  {
        logger = Logger.getLogger(MyLogger.class.getName());
        logger.setUseParentHandlers(false);
        //如果需要将日志文件写到文件系统中，需要创建一个FileHandler对象
        Handler consoleHandler = new ConsoleHandler();

        //创建日志格式文件：本次采用自定义的Formatter
        consoleHandler.setFormatter(new MyFormatter());

        //将FileHandler对象添加到Logger对象中
        logger.addHandler(consoleHandler);
    }

    public static Logger getLogger() {
        return logger;
    }

    public static void main(String[] args) {
        MyLogger.logger.info("1");
        Logger logger = MyLogger.logger;
        logger.info("2");
    }
}

import com.sun.media.jai.codec.*;

import com.sun.media.jai.codec.FileSeekableStream;
import com.sun.media.jai.codec.ImageDecoder;
import com.sun.media.jai.codec.ImageCodec;
import com.sun.media.jai.codec.TIFFEncodeParam;
import com.sun.media.jai.codec.TIFFDecodeParam;
import com.sun.media.jai.codec.JPEGEncodeParam;
import java.awt.image.RenderedImage;
import javax.media.jai.RenderedOp;
import javax.media.jai.JAI;

import java.awt.*;
import java.awt.image.DataBuffer;
import java.awt.image.RenderedImage;
import java.awt.image.renderable.ParameterBlock;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import javax.swing.*;

//本类继承自画布类，用作绘图的面板，因为Java不允许多继承，所以要用此类
class TIFBase extends Canvas
{
    ImageDecoder dec;

    TIFBase() throws IOException {
        this.TifRead();
    }
    public void TifRead() throws IOException
    {
        String currentDir = System.getProperty("user.dir");
        System.out.println("当前目录：" + currentDir);
        //FileSeekableStream fileSeekableStream = new FileSeekableStream("human_brain_from_itk_example.tif");
        FileSeekableStream fileSeekableStream = new FileSeekableStream("ex_Repo_hb9_eve1.tif");
        TIFFDecodeParam param0 = null;
        TIFFEncodeParam param = new TIFFEncodeParam();
        JPEGEncodeParam param1 = new JPEGEncodeParam();
        dec = ImageCodec.createImageDecoder("tiff", fileSeekableStream, param0);
        param.setCompression(TIFFEncodeParam.COMPRESSION_GROUP4);
        param.setLittleEndian(false); // Intel
    }

    public ImageDecoder getDec() {
        return dec;
    }

    public void setDec(ImageDecoder dec) {
        this.dec = dec;
    }

    public void TifDisplay(Graphics g) throws IOException, InterruptedException
    {
        int pagesCount = dec.getNumPages();
        System.out.println("This TIF has " + pagesCount + " image(s)");
        System.out.println();
        for (int i = 0; i < pagesCount; i++)
        {
            System.out.println("image: " + i);
            RenderedImage page = dec.decodeAsRenderedImage(i);
            DataBuffer dataBuffer = page.getData().getDataBuffer();

            //System.out.println("size: " + dataBuffer.getSize());
            int height = page.getHeight();
            int width = page.getWidth();
            //g.drawString(page.getData().toString(), 0, 0);
            for (int j = 0; j < height; j++)
            {
                for (int k = 0; k < width; k++)
                {
                    int red = dataBuffer.getElem((j * width + k) * 3);
                    int green = dataBuffer.getElem((j * width + k) * 3 + 1);
                    int blue = dataBuffer.getElem((j * width + k) * 3 + 2);
                    g.setColor(new Color(red, green, blue));
                    g.drawOval(j, k, 1, 1);
                }
            }
        }
        //Thread.sleep(10);
    }

    public void TifDisplay2(Graphics g) throws IOException, InterruptedException {
        int pagesCount = dec.getNumPages();
        System.out.println("This TIF has " + pagesCount + " image(s)");
        System.out.println();
        DataBuffer[] dataBuffers = new DataBuffer[pagesCount];
        int height = 0;
        int width = 0;
        for (int i = 0; i < pagesCount; i++)
        {
            //System.out.println("image: " + i);
            RenderedImage page = dec.decodeAsRenderedImage(i);
            //System.out.println("height: " + page.getHeight() + ", width: " + page.getWidth());
            height = page.getHeight();
            width = page.getWidth();
            dataBuffers[i] = page.getData().getDataBuffer();
        }

        int statPage = 0;
        int endPage = pagesCount;
        int gap = endPage - statPage;
        int miniColor = 3;
        for (int i = 0; i < height; i++)
        {
            for (int j = 0; j < width; j++)
            {
                int redSumary = 0;
                int greenSumary = 0;
                int blueSumary = 0;
                int validRedColorFlag = 0;
                int validGreenColorFlag = 0;
                int validBlueColorFlag = 0;
                for (int k = statPage; k < endPage; k++)
                {
                    int red = dataBuffers[k].getElem((i * width + j) * 3);
                    int green = dataBuffers[k].getElem((i * width + j) * 3 + 1);
                    int blue = dataBuffers[k].getElem((i * width + j) * 3 + 2);
                    if (red > miniColor)

                    {
                        redSumary += red;
                        validRedColorFlag++;
                    }
                    if (green > miniColor)
                    {
                        greenSumary += green;
                        validGreenColorFlag++;
                    }

                    if (blue > miniColor)
                    {
                        blueSumary += blue;
                        validBlueColorFlag++;
                    }
                }

                redSumary = (validRedColorFlag == 0) ? 0 : (redSumary / validRedColorFlag);
                greenSumary = (validGreenColorFlag == 0) ? 0 : (greenSumary / validGreenColorFlag);
                blueSumary = (validBlueColorFlag == 0) ? 0 : (blueSumary / validBlueColorFlag);

                g.setColor(new Color(redSumary, greenSumary, blueSumary));
                g.drawOval(i, j, 1, 1);
            }
        }
    }

    // 把窗口拉宽些就可。
    public void paint(Graphics g)
    {
        System.out.println("1");
        try {
            this.TifDisplay(g);
            //this.TifDisplay2(g);
        }
        catch (IOException | InterruptedException e)
        {
            throw new RuntimeException(e);
        }
    }
}

public class TIF extends JFrame
{
    public TIF()
    {
        super("画直线");
        this.setVisible(true);
        this.setBounds(200, 200, 600, 600);
    }

    public void Display() throws IOException
    {
        //创建对象
        TIFBase tifBase = new TIFBase();//创建实例
        this.getContentPane().add(tifBase);
    }

    public static void main(String[] args) throws IOException
    {
        TIF tif = new TIF();
        tif.Display();
    }
}


import com.sun.media.jai.codec.ImageDecoder;
import org.lwjgl.*;
import org.lwjgl.glfw.*;
import org.lwjgl.opengl.*;
import org.lwjgl.system.*;

import java.awt.*;
import java.awt.image.DataBuffer;
import java.awt.image.RenderedImage;
import java.io.IOException;
import java.nio.*;
import java.util.Objects;
import java.util.logging.Logger;

import static org.lwjgl.glfw.Callbacks.*;
import static org.lwjgl.glfw.GLFW.*;
import static org.lwjgl.opengl.GL32.*;
import static org.lwjgl.system.MemoryStack.*;
import static org.lwjgl.system.MemoryUtil.*;

public class HelloWorld {

    // The window handle
    private long window;
    public static Logger logger = MyLogger.logger;
    private float angle;

    private ImageDecoder dec;
    private int threshold;

    HelloWorld()  {

        //创建对象
        try {
            TIFBase tifBase = new TIFBase();//创建实例
            dec = tifBase.getDec();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public void run()
    {
        logger.info("Hello LWJGL " + Version.getVersion() + "!");

        init();
        loop();
        // Free the window callbacks and destroy the window
        glfwFreeCallbacks(window);
        glfwDestroyWindow(window);

        // Terminate GLFW and free the error callback
        glfwTerminate();
        Objects.requireNonNull(glfwSetErrorCallback(null)).free();
    }

    private void init() {
        logger.info("init");
        // Setup an error callback. The default implementation
        // will print the error message in System.err.
        GLFWErrorCallback.createPrint(System.err).set();

        angle = 5;
        threshold = 20;

        // Initialize GLFW. Most GLFW functions will not work before doing this.
        if ( !glfwInit() )
            throw new IllegalStateException("Unable to initialize GLFW");

        // Configure GLFW
        glfwDefaultWindowHints(); // optional, the current window hints are already the default
        glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // the window will stay hidden after creation
        glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // the window will be resizable

        // Create the window
        window = glfwCreateWindow(600, 600, "Hello World!", NULL, NULL);
        if ( window == NULL )
            throw new RuntimeException("Failed to create the GLFW window");

        // Setup a key callback. It will be called every time a key is pressed, repeated or released.
        glfwSetKeyCallback(window, (window, key, scancode, action, mods) -> {
            if ( key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE )
                glfwSetWindowShouldClose(window, true); // We will detect this in the rendering loop
        });

        // Get the thread stack and push a new frame
        try ( MemoryStack stack = stackPush() ) {
            IntBuffer pWidth = stack.mallocInt(1); // int*
            IntBuffer pHeight = stack.mallocInt(1); // int*

            // Get the window size passed to glfwCreateWindow
            glfwGetWindowSize(window, pWidth, pHeight);

            // Get the resolution of the primary monitor
            GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());

            // Center the window
            glfwSetWindowPos(
                    window,
                    (vidmode.width() - pWidth.get(0)) / 2,
                    (vidmode.height() - pHeight.get(0)) / 2
            );
        } // the stack frame is popped automatically

        // Make the OpenGL context current
        glfwMakeContextCurrent(window);
        // Enable v-sync
        glfwSwapInterval(1);

        // Make the window visible
        glfwShowWindow(window);
    }

    /**
     * 绘制三角形
     */
    public void DrawTriangles()
    {
        glTranslatef(-0.5f, -0.5f, -0.00f); //平移矩阵
        glRotatef(angle, 0.5f, 0.5f, 0.0f); //绕X,Y, Z轴直线旋转XX度
        glPointSize(1.0f);
        glBegin(GL_POINTS);

        try {
            int pagesCount = dec.getNumPages();
            //System.out.println("This TIF has " + pagesCount + " image(s)");
            //System.out.println();
            for (int i = 0; i < pagesCount; i++)
            {
                //System.out.println("image: " + i);
                RenderedImage page = dec.decodeAsRenderedImage(i);
                DataBuffer dataBuffer = page.getData().getDataBuffer();

                //System.out.println("size: " + dataBuffer.getSize());
                int height = page.getHeight();
                int width = page.getWidth();
                //g.drawString(page.getData().toString(), 0, 0);
                for (int j = 0; j < height; j++)
                {
                    for (int k = 0; k < width; k++)
                    {
                        int red = dataBuffer.getElem((j * width + k) * 3);
                        int green = dataBuffer.getElem((j * width + k) * 3 + 1);
                        int blue = dataBuffer.getElem((j * width + k) * 3 + 2);
                        //g.setColor(new Color(red, green, blue));
                        //System.out.println("red: " + red + ", green: " + green + ", blue: " + blue);
                        if (red > threshold )
                        {
                            glColor3b((byte) red, (byte) 0, (byte) 0);
                            glVertex3f(k / 200.0f,j / 200.0f,i / 200.0f);
                        }
                        if (green > threshold )
                        {
                            glColor3b((byte) 0, (byte) green, (byte) 0);
                            glVertex3f(k / 200.0f,j / 200.0f,i / 200.0f);
                        }
                        if (blue > threshold )
                        {
                            glColor3b((byte) 0, (byte) 0, (byte) blue);
                            glVertex3f(k / 200.0f,j / 200.0f,i / 200.0f);
                        }
                        //g.drawOval(j, k, 1, 1);
                    }
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        System.out.println("threshold: " + threshold  + ", angle: " + angle);
        if (angle >= 350)
        {
            angle = 0;
            threshold += 10;
        }
        angle+=10;
        glEnd();
    }

    public void DrawLines()
    {
        glBegin(GL_LINES);
        glVertex2i(0, 0);
        glVertex2i(0, 1);
        glEnd();
    }

    public void DrawQuads()
    {
        glBegin(GL_QUADS);

        //顶面
        glColor3f(0.0f, 1.0f, 0.0f);
        glVertex3f(1.0f, 1.0f, -1.0f);     //右上顶点
        glVertex3f(-1.0f, 1.0f, -1.0f);    //左上顶点
        glVertex3f(-1.0f, 1.0f, 1.0f);     //左下顶点
        glVertex3f(1.0f, 1.0f, 1.0f);      //右下顶点

        //底面
        glColor3f(1.0f, 0.5f, 0.0f);
        glVertex3f(1.0f, -1.0f, 1.0f);     //右上顶点
        glVertex3f(-1.0f, -1.0f, 1.0f);    //左上顶点
        glVertex3f(-1.0f, -1.0f, -1.0f);   //左下顶点
        glVertex3f(1.0f, -1.0f, -1.0f);    //右下顶点

        //前面
        glColor3f(1.0f, 0.0f, 0.0f);
        glVertex3f(1.0f, 1.0f, 1.0f);      //右上顶点
        glVertex3f(-1.0f, 1.0f, 1.0f);     //左上顶点
        glVertex3f(-1.0f, -1.0f, 1.0f);    //左下顶点
        glVertex3f(1.0f, -1.0f, 1.0f);     //右下顶点

        //后面
        glColor3f(1.0f, 1.0f, 0.0f);
        glVertex3f(1.0f, -1.0f, -1.0f);    //右上顶点
        glVertex3f(-1.0f, -1.0f, -1.0f);   //左上顶点
        glVertex3f(-1.0f, 1.0f, -1.0f);    //左下顶点
        glVertex3f(1.0f, 1.0f, -1.0f);     //右下顶点

        //左侧面
        glColor3f(0.0f, 0.0f, 1.0f);
        glVertex3f(-1.0f, 1.0f, 1.0f);     //右上顶点
        glVertex3f(-1.0f, 1.0f, -1.0f);    //左上顶点
        glVertex3f(-1.0f, -1.0f, -1.0f);   //左下顶点
        glVertex3f(-1.0f, -1.0f, 1.0f);     //右下顶点

        //右侧面
        glColor3f(1.0f, 0.0f, 1.0f);
        glVertex3f(1.0f, 1.0f, -1.0f);     //右上顶点
        glVertex3f(1.0f, 1.0f, 1.0f);      //左上顶点
        glVertex3f(1.0f, -1.0f, 1.0f);     //左下顶点
        glVertex3f(1.0f, -1.0f, -1.0f);    //右下顶点

        glEnd();
    }
    private void loop() {
        logger.info("loop");

        // This line is critical for LWJGL's interoperation with GLFW's
        // OpenGL context, or any context that is managed externally.
        // LWJGL detects the context that is current in the current thread,
        // creates the GLCapabilities instance and makes the OpenGL
        GL.createCapabilities();
        //DrawQuads();
        //-----------------------------------------
        //glLoadIdentity();   //重置当前的模型观察矩阵

        //————————————————
        //版权声明：本文为CSDN博主「贝勒里恩」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
        //原文链接：https://blog.csdn.net/Mr_robot_strange/article/details/123682686
        while (true)
        {
            //glClearColor(1.0f, 1.0f, 0.0f, 0.0f);
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //清除屏幕和深度缓存

            //-----------------------------------------
            glLoadIdentity();   //重置当前的模型观察矩阵

            //DrawLines();
            DrawTriangles();
            glfwSwapBuffers(window);
            glfwPollEvents();
        }

    }

    public static void main(String[] args) {
        logger.info("main");
        new HelloWorld().run();
    }

}

这上边的代码如果需要运行，需要依赖这些JAR包： 

运行效果如下:

TIFF格式图片文件不同阈值旋转_哔哩哔哩_bilibili

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

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

相关文章

Oracle数据库新手零基础入门，Oracle安装配置和操作使用详解

Oracle数据库新手零基础入门，Oracle安装配置和操作使用详解

一、教程描述 本套教程是专门为初学者量身定制的&#xff0c;无需任何Oracle数据库基础&#xff0c;课程采用循序渐进的教学方式&#xff0c;从Oracle数据库的基础知识开始讲起&#xff0c;并不会直接涉及到一项具体的技术&#xff0c;而是随着课程的不断深入&#xff0c;一些…
阅读更多...
基于python的leetcode算法介绍之动态规划

基于python的leetcode算法介绍之动态规划

文章目录 零 算法介绍一 例题介绍 使用最小花费爬楼梯问题分析 Leetcode例题与思路[118. 杨辉三角](https://leetcode.cn/problems/pascals-triangle/)解题思路题解 [53. 最大子数组和](https://leetcode.cn/problems/maximum-subarray/)解题思路题解 [96. 不同的二叉搜索树](h…
阅读更多...
自动驾驶预测-决策-规划-控制学习（4）：预测分析文献阅读

自动驾驶预测-决策-规划-控制学习（4）：预测分析文献阅读

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、摘要分析1.Transformer模型是什么&#xff1f;什么是自注意力机制&#xff1f; 2.数据集是什么&#xff1f;3.预测车辆行驶轨迹和车辆换道意图4. LSTM 网络…
阅读更多...
Pytest成魔之路 —— fixture 之大解剖！

Pytest成魔之路 —— fixture 之大解剖！

1. 简介 fixture是pytest的一个闪光点&#xff0c;pytest要精通怎么能不学习fixture呢&#xff1f;跟着我一起深入学习fixture吧。其实unittest和nose都支持fixture&#xff0c;但是pytest做得更炫。 fixture是pytest特有的功能&#xff0c;它用pytest.fixture标识&#xff0c…
阅读更多...
MybatisPlus—快速入门

MybatisPlus—快速入门

目录 1.使用MybatisPlus的基本步骤 1.1引入MybatisPlus的起步依赖 1.2 定义Mapper 2.MybatisPlus常用注解 2.1 TableName 2.2 TableId 2.3 TableField 2.4 小结 3. 常用配置 4. 总结 1.使用MybatisPlus的基本步骤 1.1引入MybatisPlus的起步依赖 MyBatisPlus官方提…
阅读更多...
如何使用 NFTScan NFT API 在 PlatON 网络上开发 Web3 应用

如何使用 NFTScan NFT API 在 PlatON 网络上开发 Web3 应用

PlatON 是由万向区块链和矩阵元主导开发的面向下一代的全球计算架构&#xff0c;创新性的采用元计算框架 Monad 和基于 Reload 覆盖网络的同构多链架构&#xff0c;其愿景是成为全球首个提供完备隐私保护能力的运营服务网络。它提供计算、存储、通讯服务&#xff0c;并提供算力…
阅读更多...
软件测试|什么是Python构造方法，构造方法如何使用？

软件测试|什么是Python构造方法，构造方法如何使用？

构造方法&#xff08;Constructor&#xff09;是面向对象编程中的重要概念&#xff0c;它在创建对象时用于初始化对象的实例变量。在Python中&#xff0c;构造方法是通过特殊的名称__init__()来定义的。本文将介绍Python构造方法的基本概念、语法和用法。 什么是构造方法&…
阅读更多...
React使用动态标签名称

React使用动态标签名称

最近在一项目里&#xff08;React antd&#xff09;遇到一个需求&#xff0c;某项基础信息里有个图标配置&#xff08;图标用的是antd的Icon组件&#xff09;&#xff0c;该项基础信息的图标信息修改后&#xff0c;存于后台数据库&#xff0c;后台数据库里存的是antd Icon组件…
阅读更多...
ArkTS - 网络请求

ArkTS - 网络请求

一、Axios请求 应用通过HTTP发起一个数据请求&#xff0c;支持常见的GET、POST、OPTIONS、HEAD、PUT、DELETE、TRACE、CONNECT方法。 前端开发肯定都使用过一个叫axios的第三方库&#xff0c;它是是一个基于 promise 的网络请求库&#xff0c;可以用于浏览器和 node.js&…
阅读更多...
Rust 字符串 初步了解

Rust 字符串 初步了解

rust 的字符串 。字符串不是复合类型&#xff0c; String 和 &str &#xff1a; String 具有所有权&#xff0c;是存储在堆上的。&str 没有所有权&#xff0c;是对 String 的引用。字符串字面量也是 &str 类型&#xff0c;存储在栈上。 切片&#xff08;slice&a…
阅读更多...
Nacos与Eureka

Nacos与Eureka

一、前言 在构建和管理微服务架构时&#xff0c;选择适当的服务注册中心至关重要。Nacos和Eureka都是微服务体系结构中常用的服务注册和发现工具。本文将探讨它们之间的区别&#xff0c;帮助开发者在选择适合其项目需求的注册中心时做出明智的决策。 二、架构和适用场景 Nacos …
阅读更多...
TSConfig 配置（tsconfig.json)

TSConfig 配置（tsconfig.json)

详细总结一下TSConfig 的相关配置项。个人笔记&#xff0c;仅供参考&#xff0c;欢迎批评指正&#xff01; 另外&#xff0c;如果想了解更多ts相关知识&#xff0c;可以参考我的其他笔记&#xff1a; vue3ts开发干货笔记ts相关笔记&#xff08;基础必看&#xff09;ts相关笔记…
阅读更多...
【linux笔记1】

【linux笔记1】

目录 【linux笔记1】文件内容的理解用户管理用户管理命令添加用户切换用户修改用户信息删除用户 用户组 【linux笔记1】 文件内容的理解 etc文件夹&#xff1a;etc是拉丁语"et cetera"的缩写&#xff0c;意思是“和其他的”或“等等”。在linux系统中&#xff0c;“…
阅读更多...
YOLOv5改进 | 卷积篇 | SAConv轻量化的可切换空洞卷积（附修改后的C3+Bottleneck）

YOLOv5改进 | 卷积篇 | SAConv轻量化的可切换空洞卷积（附修改后的C3+Bottleneck）

一、本文介绍 本文给大家带来的改进机制是可切换的空洞卷积（Switchable Atrous Convolution, SAC）是一种创新的卷积网络机制，专为增强物体检测和分割任务中的特征提取而设计。SAC的核心思想是在相同的输入特征上应用不同的空洞率进行卷积，并通过特别设计的开关函数来融合这…
阅读更多...
sensor 点亮出图后，画面全黑是为什么？

sensor 点亮出图后，画面全黑是为什么？

同事在点一个思特威的 sensor sc035hgs&#xff0c;这个 sensor 主要负责数据采集&#xff0c;然后给到后面的 NN&#xff08;神经网络&#xff09;去做处理。 点亮出图后&#xff0c;画面很黑&#xff0c;如下图所示&#xff1a; 因为没拿到板子&#xff0c;只能盲猜&#xf…
阅读更多...
[蓝桥 2023 ]三带一

[蓝桥 2023 ]三带一

问题描述 小蓝和小桥玩斗地主&#xff0c;小蓝只剩四张牌了&#xff0c;他想知道是否是“三带一”牌型。 所谓“三带一”牌型&#xff0c;即四张手牌中&#xff0c;有三张牌一样&#xff0c;另外一张不与其他牌相同&#xff0c;换种说法&#xff0c;四张手牌经过重新排列后&am…
阅读更多...
企业档案集中式管理什么意思？企业档案集中式管理的特点

企业档案集中式管理什么意思？企业档案集中式管理的特点

企业档案集中式管理是指将企业所有的档案资料集中存放、管理和维护的一种方式。在集中式管理中&#xff0c;企业将所有的档案资料集中存放在一个统一的档案中心或档案馆中&#xff0c;通过专门的档案管理人员负责对档案资料进行分类、整理、存储和检索&#xff0c;确保档案资料…
阅读更多...
Linux操作系统基础(12)：Linux的Shell解释器

Linux操作系统基础(12)：Linux的Shell解释器

1. Shell的介绍 在Linux中&#xff0c;Shell 是一种命令行解释器&#xff0c;它是用户与操作系统内核之间的接口&#xff0c;它负责解释用户输入的命令&#xff0c;并将其转换成系统调用或其他操作系统能够执行的指令。 Shell 提供了一种交互式的方式来与操作系统进行通信&am…
阅读更多...
Apache Doris 2.0.2 安装步骤 Centos8

Apache Doris 2.0.2 安装步骤 Centos8

Linux 操作系统版本需求 Linux 系统版本当前系统版本CentOS7.1 及以上CentOS8Ubuntu16.04 及以上- 软件需求 软件版本当前版本Java1.81.8.0_391GCC4.8.2 及以上gcc (GCC) 8.5.0 20210514 (Red Hat 8.5.0-4) 1、查看操作系统版本 方法 1&#xff1a;使用命令行 打开终端或…
阅读更多...
第九节HarmonyOS 常用基础组件9-TextArea

第九节HarmonyOS 常用基础组件9-TextArea

1、描述 多行文本输入框组件&#xff0c;当输入的文本内容超过组件宽度时会自动换行显示。 2、接口 TextArea(value?:{placeholder?: ResourceStr, text?: ResourceStr, controller?: TextAreaController}) 3、参数 参数名 参数类型 必填 描述 placeholder Resour…
阅读更多...
最新文章

Copyright @ 2022~2023