Unity 3D : 解 3D LUT Cube 檔案

最新推荐文章于 2024-05-05 00:59:33 发布
最新推荐文章于 2024-05-05 00:59:33 发布
阅读量2k 收藏 5
点赞数 1
分类专栏： Unity 3D 檔案編解碼
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38884324/article/details/82595234
版权

前言 :

解 3D LUT Cube 檔案

執行結果 :

这里写图片描述

偷吃步作法 :

using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;

public class Run : MonoBehaviour
{
    public Transform par;
    public Transform obj;

    void Start()
    {
        Cube cube = new Cube();

        float[,,,] cube_color64 = cube.GetCube("C:/A/My.cube");

        print("cube.size : " + cube.size);
        
        float[,,,] cube_color256 = new float[256, 256, 256, 3];

        int oSize = cube.size - 1;

        int targetSize = 256;

		// 預設是 += 8, 所以有空格，如果你用 ++，小心爆炸 !
        for (int z = 0; z < targetSize; z += 8)
        {
            for (int y = 0; y < targetSize; y += 8)
            {
                for (int x = 0; x < targetSize; x += 8)
                {
                    float targetX = x * (oSize / (float)targetSize);
                    float targetY = y * (oSize / (float)targetSize);
                    float targetZ = z * (oSize / (float)targetSize);

                    int x0 = (int)targetX;
                    int y0 = (int)targetY;
                    int z0 = (int)targetZ;
                    int x1 = x0 + 1;
                    int y1 = y0 + 1;
                    int z1 = z0 + 1;

                    float X = targetX - x1;
                    float Y = targetY - y1;
                    float Z = targetZ - z1;

                    float w1 = (1 - X) * (1 - Y) * (1 - Z);
                    float w2 = X * (1 - Y) * (1 - Z);
                    float w3 = (1 - X) * Y * (1 - Z);
                    float w4 = (1 - X) * (1 - Y) * Z;
                    float w5 = X * (1 - Y) * Z;
                    float w6 = (1 - X) * Y * Z;
                    float w7 = X * Y * (1 - Z);
                    float w8 = X * Y * Z;
                    
                    Color c000 = new Color(cube_color64[x0, y0, z0, 0], cube_color64[x0, y0, z0, 1], cube_color64[x0, y0, z0, 2]);
                    Color c100 = new Color(cube_color64[x1, y0, z0, 0], cube_color64[x1, y0, z0, 1], cube_color64[x1, y0, z0, 2]);
                    Color c010 = new Color(cube_color64[x0, y1, z0, 0], cube_color64[x0, y1, z0, 1], cube_color64[x0, y1, z0, 2]);
                    Color c001 = new Color(cube_color64[x0, y0, z1, 0], cube_color64[x0, y0, z1, 1], cube_color64[x0, y0, z1, 2]);
                    Color c101 = new Color(cube_color64[x1, y0, z1, 0], cube_color64[x1, y0, z1, 1], cube_color64[x1, y0, z1, 2]);
                    Color c011 = new Color(cube_color64[x0, y1, z1, 0], cube_color64[x0, y1, z1, 1], cube_color64[x0, y1, z1, 2]);
                    Color c110 = new Color(cube_color64[x1, y1, z0, 0], cube_color64[x1, y1, z0, 1], cube_color64[x1, y1, z0, 2]);
                    Color c111 = new Color(cube_color64[x1, y1, z1, 0], cube_color64[x1, y1, z1, 1], cube_color64[x1, y1, z1, 2]);

                    Transform t = Instantiate<Transform>(obj);
                    t.position = new Vector3(x, y, z);

                    t.GetComponent<Renderer>().material.color = new Color(
                        c000.r * w1 + c100.r * w2 + c010.r * w3 + c001.r * w4 + c101.r * w5 + c011.r * w6 + c110.r * w7 + c111.r * w8,
                        c000.g * w1 + c100.g * w2 + c010.g * w3 + c001.g * w4 + c101.g * w5 + c011.g * w6 + c110.g * w7 + c111.g * w8,
                        c000.b * w1 + c100.b * w2 + c010.b * w3 + c001.b * w4 + c101.b * w5 + c011.b * w6 + c110.b * w7 + c111.b * w8
                        );
                }
            }
        }
    }

    bool isShowCube = false;

    void ShowCube(float[,,,] cube_color)
    {
        isShowCube = true;
        for (int z = 0; z < cube_color.GetLength(2); z += 2)
        {
            for (int y = 0; y < cube_color.GetLength(1); y += 2)
            {
                for (int x = 0; x < cube_color.GetLength(0); x += 2)
                {
                    float R = cube_color[x, y, z, 0];
                    float G = cube_color[x, y, z, 1];
                    float B = cube_color[x, y, z, 2];

                    Transform t = Instantiate<Transform>(obj);
                    t.parent = par;
                    t.localPosition = new Vector3(R, G, B) * 48;
                    t.GetComponent<Renderer>().material.color = new Color(R, G, B);
                }
            }
        }
    }
}

好一點的作法 :

using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using UnityEngine.UI;

public class LUT3D : MonoBehaviour
{
    public Transform par;
    public Transform obj;

    public Texture2D inpurtTexture;
    public RawImage outputImage;


    void Start()
    {
        //float[,,,] table = LoadTable("C:/A/My.cube");

        float[,,,] table = LoadTable("C:/A/Fuji.cube");
        //float[,,,] table = LoadTable("C:/A/FLog_FGamut_to_FLog_BT.709_33grid_V.1.00.cube");


        //ShowCube(LoadTable("C:/A/Fuji.cube"), 8);
        //ShowCube(new Cube().GetCube("C:/A/Fuji.cube"), 1);

        //ShowCube(LoadTable("C:/A/My.cube"), 8);
        //ShowCube(new Cube().GetCube("C:/A/My.cube"), 2);

        //ShowCube(LoadTable("C:/A/FLog_FGamut_to_FLog_BT.709_33grid_V.1.00.cube"), 8);
        //ShowCube(new Cube().GetCube("C:/A/FLog_FGamut_to_FLog_BT.709_33grid_V.1.00.cube"), 1);



        Texture2D t = new Texture2D(inpurtTexture.width, inpurtTexture.height, TextureFormat.RGBAFloat, false);

        for (int y = 0; y < t.height; y++)
        {
            for (int x = 0; x < t.width; x++)
            {
                Color c = inpurtTexture.GetPixel(x, y);
                int r = Mathf.CeilToInt(c.r * 255);
                int g = Mathf.CeilToInt(c.g * 255);
                int b = Mathf.CeilToInt(c.b * 255);

                float R = table[r, g, b, 0];
                float G = table[r, g, b, 1];
                float B = table[r, g, b, 2];

                t.SetPixel(x, y, new Color(R, G, B));
            }
        }

        t.Apply();
        outputImage.texture = t;
    }

    float[,,,] LoadTable(string path)
    {
        Cube cube = new Cube();

        float[,,,] cube_color64 = cube.GetCube(path);

        print("cube.size : " + cube.size);

        float[,,,] cube_color256 = new float[256, 256, 256, 3];

        int oSize = cube.size;

        int targetSize = 256;

        int scale = targetSize / oSize;

        print("scale : " + scale);

        for (int z = 0; z < targetSize - scale; z++)
        {
            for (int y = 0; y < targetSize - scale; y++)
            {
                for (int x = 0; x < targetSize - scale; x++)
                {
                    float targetX = x * (oSize / (float)targetSize);
                    float targetY = y * (oSize / (float)targetSize);
                    float targetZ = z * (oSize / (float)targetSize);

                    int x0 = (int)targetX; // 0~63
                    int y0 = (int)targetY;
                    int z0 = (int)targetZ;

                    int x1 = x0 + 1; // 1~64
                    int y1 = y0 + 1;
                    int z1 = z0 + 1;

                    float X = targetX - x0;
                    float Y = targetY - y0;
                    float Z = targetZ - z0;

                    Color c000 = new Color(cube_color64[x0, y0, z0, 0], cube_color64[x0, y0, z0, 1], cube_color64[x0, y0, z0, 2]);
                    Color c100 = new Color(cube_color64[x1, y0, z0, 0], cube_color64[x1, y0, z0, 1], cube_color64[x1, y0, z0, 2]);
                    Color c010 = new Color(cube_color64[x0, y0, z1, 0], cube_color64[x0, y0, z1, 1], cube_color64[x0, y0, z1, 2]);
                    Color c001 = new Color(cube_color64[x0, y1, z0, 0], cube_color64[x0, y1, z0, 1], cube_color64[x0, y1, z0, 2]);
                    Color c101 = new Color(cube_color64[x1, y1, z0, 0], cube_color64[x1, y1, z0, 1], cube_color64[x1, y1, z0, 2]);
                    Color c011 = new Color(cube_color64[x0, y1, z1, 0], cube_color64[x0, y1, z1, 1], cube_color64[x0, y1, z1, 2]);
                    Color c110 = new Color(cube_color64[x1, y0, z1, 0], cube_color64[x1, y0, z1, 1], cube_color64[x1, y0, z1, 2]);
                    Color c111 = new Color(cube_color64[x1, y1, z1, 0], cube_color64[x1, y1, z1, 1], cube_color64[x1, y1, z1, 2]);

                    Color c00 = new Color(Mathf.Lerp(c000.r, c100.r, X), Mathf.Lerp(c000.g, c100.g, X), Mathf.Lerp(c000.b, c100.b, X));
                    Color c01 = new Color(Mathf.Lerp(c001.r, c101.r, X), Mathf.Lerp(c001.g, c101.g, X), Mathf.Lerp(c001.b, c101.b, X));
                    Color c10 = new Color(Mathf.Lerp(c010.r, c110.r, X), Mathf.Lerp(c010.g, c110.g, X), Mathf.Lerp(c010.b, c110.b, X));
                    Color c11 = new Color(Mathf.Lerp(c011.r, c111.r, X), Mathf.Lerp(c011.g, c111.g, X), Mathf.Lerp(c011.b, c111.b, X));

                    Color c0 = new Color(Mathf.Lerp(c00.r, c10.r, Z), Mathf.Lerp(c00.g, c10.g, Z), Mathf.Lerp(c00.b, c10.b, Z));
                    Color c1 = new Color(Mathf.Lerp(c01.r, c11.r, Z), Mathf.Lerp(c01.g, c11.g, Z), Mathf.Lerp(c01.b, c11.b, Z));

                    Color c = new Color(Mathf.Lerp(c0.r, c1.r, Y), Mathf.Lerp(c0.g, c1.g, Y), Mathf.Lerp(c0.b, c1.b, Y));

                    cube_color256[x, y, z, 0] = c.r;
                    cube_color256[x, y, z, 1] = c.g;
                    cube_color256[x, y, z, 2] = c.b;

                    //print(Mathf.CeilToInt(c.r * 255));

                    // 最後一個
                    int end = targetSize - scale - 1;
                    if (x == end || y == end || z == end)
                    {
                        for (int k = 1; k < scale + 1; k++)
                        {
                            // 這邊也要做插值，目前沒做
                            float r = cube_color64[x1, y1, z1, 0];
                            float g = cube_color64[x1, y1, z1, 1];
                            float b = cube_color64[x1, y1, z1, 2];

                            cube_color256[x + k, y + k, z + k, 0] = r;
                            cube_color256[x + k, y + k, z + k, 1] = g;
                            cube_color256[x + k, y + k, z + k, 2] = b;
                        }
                    }
                }
            }
        }
        return cube_color256;
    }

    void ShowCube(float[,,,] cube_color, int step)
    {
        for (int z = 0; z < cube_color.GetLength(2); z += step)
        {
            for (int y = 0; y < cube_color.GetLength(1); y += step)
            {
                for (int x = 0; x < cube_color.GetLength(0); x += step)
                {
                    float R = cube_color[x, y, z, 0];
                    float G = cube_color[x, y, z, 1];
                    float B = cube_color[x, y, z, 2];

                    Transform t = Instantiate<Transform>(obj);
                    t.parent = par;
                    t.localPosition = new Vector3(R, G, B) * 48;
                    t.GetComponent<Renderer>().material.color = new Color(R, G, B);

                    //print((int)(R * 255));
                }
            }
        }
    }
}

Cube.cs :

using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;

public class Cube
{
    public string title;
    public int size;

    public float[,,,] GetCube(string path)
    {
        string[] lines = File.ReadAllLines(path);

        int index = 0;

        //index = GetTitle(lines, index, out title);
        //print("[ " + index + " ] Title : " + title);

        index = GetLut3DSize(lines, index, out size);
        //print("[ " + index + " ] LUT 3D Size : " + lut3DSize);

        float[,,,] cube = new float[size, size, size, 3]; // X, Y, Z, RGB

        int allSize = size * size * size;

        int x = 0, y = 0, z = 0;

        for (int i = index, k = 0; k < allSize; i++)
        {
            string line = lines[i];
            if (CanRead(line) == false) continue;

            string[] s = line.Split(' ');

            float R = float.Parse(s[0]);
            float G = float.Parse(s[1]);
            float B = float.Parse(s[2]);

            x = k % size;

            cube[x, y, z, 0] = R;
            cube[x, y, z, 1] = G;
            cube[x, y, z, 2] = B;

            if (x == size-1)
            {
                if (y == size-1)
                {
                    y = 0;
                    z++;
                }
                else
                {
                    y++;
                }
            }
            k++;
        }

        return cube;
    }

    bool CanRead(string line)
    {
        if (line.Length == 0) return false;
        if (line[0] == '#') return false;
        return true;
    }

    // 讀完後，指針往後一格
    int GetTitle(string[] lines, int index, out string title)
    {
        title = null;
        for (int i = index; i < lines.Length; i++)
        {
            string s = lines[i];
            if (s.IndexOf("TITLE") != -1)
            {
                int start = s.IndexOf("\"") + 1;
                int end = s.LastIndexOf("\"");
                int length = end - start;
                title = s.Substring(start, length);
                index = i + 1;
                break;
            }
        }
        return index;
    }

    // 讀完後，指針往後一格
    int GetLut3DSize(string[] lines, int index, out int size)
    {
        size = -1;
        for (int k = index; k < lines.Length; k++)
        {
            string s = lines[k];
            if (s.IndexOf("LUT_3D_SIZE") != -1)
            {
                string[] ss = s.Split(' ');
                for (int i = 1; i < ss.Length; i++)
                {
                    if (int.TryParse(ss[i], out size))
                    {
                        index = k + 1;
                        break;
                    }
                }
                break;
            }
        }
        return index;
    }
}

參考 :

https://www.lightillusion.com/luts.html
http://www.fallenempiredigital.com/blog/2012/12/04/luts-part-1-what-is-a-lut/
https://en.wikipedia.org/wiki/3D_lookup_table

彥霖
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OpenCV学习笔记（十一）之LUT使用
夜月枫雪
07-03 5398
LUT原理   提到LUT，很多人可能都会觉得这是一个很专业很高深的词汇，LUT其实就是Look Up Table（颜色查找表）的缩写，简单点儿理解就是：通过LUT，我们可以将一组RGB值输出为另一组RGB值，从而改变画面的曝光与色彩。LUT文件就是一个包含了可以改变输入颜色信息的矩阵数据。 ...
如何将LUT的CUBE或3DL文件转换为PNG图像
xghxgb的博客
01-12 7459
如何将LUT的CUBE或3DL文件转换为PNG图像 什么是颜色查询表（LUT）？ 颜色查询表将源照片颜色替换为不同的颜色，以产生戏剧性的效果。 PhotoGoTool 是App Store上的一个应用。 1.在photoshop中打开一个neutral LUT PNG图像 在Photoshop中打开一个neutral LUT png图像。PhotoGoTool 提供了一个neutral LUT，您可以在以下链接找到 https://i.postimg.cc/KjrGL31d/neutral-lut.png.
3D LUT图像处理
程序员深度学习
10-31 8204
1. 介绍 在我们开始之前，先对必要的背景知识做一些简单的铺垫。LUT 是 Lookup Table 的缩写，在图像处理方面，LUT 可以用来完成类似滤镜的效果，其原理本质上就是一个映射关系，输入颜色 (r, g, b)，通过 LUT 去查找，得到一个新的颜色 (R, G, B)，则完成了一次映射操作。 LUT 又分为 1D LUT 和 3D LUT，1D LUT 是指 R, G, B 三个分量互相不影响，都是独立映射，即存在 3 个映射 f1f_1f1​, f2f_2f2​, f3f_3f3​，有如下关.
OpenCV图像处理之LUT
最新发布
qq_44816992的博客
05-05 1708
Look Up Table（颜色查找表）、俗称调色板，一行多列的矩阵/数组；可以通过图像像素值或者一组数据值查找表（LUT）中对应的值进行重映射（当像素值x = 180 ， 去查找表中第180个位置的值将原x替换）1、LUT函数提供了一种颜色以及颜色空间与另一种颜色及颜色空间的映射方法，虽然OpenCV本身提供的函数对非8bit图像不友好，但是我们可以利用其思想自己动手实现2、通过构建LUT，我们可以直观的看到我们算法的特点（例：色谱颜色过渡自然程度、灰度增强灰度值偏亮、暗等等）src%29。
parse-cube-lut:多维数据集LUT（IRIDASAdobe）解析器
05-05
解析多维数据集 多维数据集LUT（IRIDAS / Adob​​e）解析器 根据定义解析立方体LUT文件。 LUT文件可用于颜色分级，封装复杂的色彩空间转换或模拟用于摄影和视频的胶卷。 安装 $ npm install parse-cube-lut 用法 var parseCubeLUT = require ( 'parse-cube-lut' ) ; var fs = require ( 'fs' ) ; var buf = fs . readFileSync ( 'fuji400h.cube' ) ; var lut = parseCubeLUT ( buf ) ; console . log ( lut ) ; /* { title: 'Fuji 400H LUT', type: '3D', size: 25, domain: [ [ 0, 0, 0 ], [ 1, 1
LUT预设.cube格式PR/达芬奇/FCP/剪映等视频电影调色预设LUTs
qq_16853349的博客
01-09 1109
这些LUT经过专业设计，以模仿电影行业中的电影质量、深度和情感，使其成为电影制作人、摄像师和内容创作者的理想选择，希望为你的作品带来专业的电影色彩。浪漫电影LUT：这些LUT具有柔和的调色板和柔和的对比，唤起情感，营造梦幻浪漫的氛围，非常适合拍摄婚礼视频、爱情故事和情感内容。冒险电影LUT：这些LUT非常适合户外和充满动作的镜头，增强了鲜艳的色彩，提高了动态范围，适合旅行视频日志、冒险纪录片等。冬季电影LUT：这些LUT反映了冬季的凉爽色调，强调了雪景和寒冷环境的美丽，适合冬季运动视频和假日主题项目。
如何在final cut pro x中应用3D LUT？cube预设怎么安装在fcpx软件中？
mac666999的博客
03-07 1831
3D LU预设包含很多格式的预设，今天小编要和大家介绍的是cube格式的预设怎么安装，想必很多用户都习惯使用final cut pro x视频制作软件吧，那么如何在final cut pro x中应用3D LUT？cube预设怎么安装在fcpx软件中？还不会的小伙伴看看今天的教程吧！ 步骤1 选择时间轴上的剪辑。 步骤2 访问效果浏览器。 步骤3 在“效果”浏览器中的“颜色”类别下，选择“自定义LUT”并将其拖到剪辑上。 步骤4 访问视频检查器。 步骤5 使用自定 LUT下拉...
Unity3D：时间 Time2
08-08
Unity3D：时间 TimeTime类包含了一个重要的类变量deltaTime，它表示距上一次调用Update或FixedUpdate所用的时间。} 如果想要
Unity3D教程：赛车漂移算法1
08-08
首先一点重要的，所有汽车移动，转弯都必须使用wheelcollider提供的函数，用wheelcollider方法可以保证车子正常运动，但不会漂移（要么过快车速
Unity3D：Unity3D Pro的Siphon实现
02-06
Unity3D 适用于Unity3D Pro的Siphon实现，4.0+ 该项目未维护。 考虑一个替代方案，例如 。
Unity3D教程：抗锯齿设置1
08-08
Unity3D教程：抗锯齿设置 Posted on 2013年04月17日 by U3d / Unity3D 软件操作 /被围观 417 次 出现锯齿可能是2个
AmplifyLUTPack(unity3D色彩插件)1.0官方免费版
07-25
Amplify LUT Pack是一款优秀的unity 3D色彩插件，为用户提供了丰富多彩的Unity 3D高品质彩色分级预置放大色彩的集合。该套装包含200多种LUT，从电影胶片到电影外观，热门游戏和风格化的外观。改变心情，使您的项目达到一个新的水平，增加混合功能放大颜色。该包还包括一个功能齐全的LUT浏览器，只需点击一个按钮即可进行即时预览。需要的朋友不要 错过了！ 软件介绍 包含200多
将 Adob​​e Cube LUT 应用于图像的工具_python_代码_下载
06-15
概述 许多专业人士应用 3D LUT 为他们的图像和视频获得某种外观和感觉，这通常使用 Adob​​e Photoshop 或 Final Cut Pro 等专有软件完成。pycubelut被创建为第一个易于使用的开源命令行工具，可将 Adob​​e Cube LUT 应用于图像。 在图像的上下文中，查找表 (LUT) 是描述 RGB 值转换的表。图像处理中使用了多种类型的 LUT，最常见的是 1D LUT 和 3D LUT。1D LUT 包含每个颜色通道的独立变换，这意味着将定义三个 1D LUT（用于红色、绿色和蓝色）。但是，3D LUT 将 RGB 空间中的每种颜色直接映射到另一种指定颜色 (ℝ³ -> ℝ³)，从而允许进行强大且任意的转换，例如灰度、伪色和色相偏移。所有颜色效果，例如伽马、对比度、亮度等，都可以编码为 3D LUT。 3D LUT 本质上是立方体形状的网格（因此 Adob​​e 使用.cube其 LUT 文件扩展名）。为了编码完整的 8 位 RGB 空间的无损变换，需要 256x256x256 映射。但是，Cube 格式允许对 LUT 中的值进行插值，该 L
imlut（img，lut，kind，order，colorScheme）：此功能将1D或3D LUT应用于图像以进行颜色梯度校准。-matlab开发
05-30
此功能将 1D 或 3D LUT 应用于图像数据以进行颜色梯度校准。 可以在此处找到 LUT 的详细描述： http://www.lightillusion.com/luts.html 语法：[img_lut] = imlut（img，lut，kind，order） 输入： img - 应用 lut 的图像，格式为 double， uint8 或 uint16 lut - 颜色查找表（1D 或 3D） kind - 字符串 '1D' 或 '3D' 指定是使用 1D LUT 还是 3D LUT order - LUT 条目的顺序。 我们区分“标准”（默认）和“逆”顺序。 例子： 标准顺序 逆顺序RGBRGB 0 0 0 0 0 0 1 0 0 0 0 1 2 0 0 0 0 2 0 1 0 0 1 0 1 1 0 0 1 1 2 1 0 0 1 2 0 2 0 0 2 0 …… 2 2
Unity3D脚本：读取同名物体2
08-08
Unity3D脚本：读取同名物体 Posted on 2013年02月18日 by U3d / Unity3D脚本/插件/被围观 235 次 在Unity场景里
如何安装LUT预设？达芬奇/FCP/PR怎么安装LUT预设.cube格式文件的教程
qq_16853349的博客
12-16 1833
从那里，只需单击“LUT”字段旁边的下拉菜单，然后选择“选择自定义 LUT”。在右侧面板上，访问“基本”工具，然后单击“配置文件浏览器”图标（它在“基本”面板右上角显示为 4 个小框）。从下拉菜单中单击“加载 3D LUT” ，然后导航到您选择的 LUT 文件（.cube 格式），选择后，LUT 将自动应用于您的图像。如果未打开，请选择顶部菜单栏中的“窗口” ，然后单击“属性”。在“属性”选项卡上，选择左上角的小网格状图标（如果尚未选择），然后选择“3DLUT 文件”（如果默认情况下未选择）。
美颜你的Unity--使用Lut为Unity调色
热门推荐
Irisviel的专栏
06-05 2万+
文章一般会先在我的自建博客发布，这边更新的会晚一些。 大家看了上面这张图片一定就明白本文的主题了，没错，今天的主题就是带大家一起舔小圆 （╯‵□′）╯︵┴─┴ 哈哈，不开玩笑了。上图展示了相机的一个常用的功能–滤镜，相信大家在用手机拍照的时候都用过滤镜吧，相机自带的滤镜可以一键调整照片色调，让我们不用专门学习相关的摄影知识就能拍出想要的效果，非常的方便与实用。今天要研究的内容就是在Unit
对lut的理解
uchihalyn的博客
07-01 721
文章目录参考资料简单理解 参考资料 lut_unityShader 简单理解 查找表（look-up-table）简称为LUT 这里就理解一下3d LUT 根据输入的rgb值使用lut查找到变换后的rgb值。 例子8x8 的lut图 分别看一眼它的rgb通道。 r通道表示，每个小方块的从左到右是0-1渐变，也就是r是沿着横轴查找。 g通道表示，g是沿着纵轴从上到下查找。 这两个确定（0，0）在左上角。 b通道表示每个小方格是代表一个灰度。 所以查找输入rgb时，先通过b的值找到对应小方格。然后通过以小方格
怎么理解 64x64x64 3D LUT？
Jackery's Special Column
12-15 4364
开始的的理解是RGB每个分量都分为64级，这样的查找表的数据应该是64x64x64个。 但是最新的LUT升级文件中查找表的数据为4913个这又和最常用的17x17x17的3D LUT是一致的。 请问怎么理解64x64x64 3D LUT呢？ 1. 关于3D LUT比较常用的是立方体分割法，以下图为例，就是把色彩空间划分成八个立方体，坐标轴一般为RGB，每一个边分割为两段三个节点，这就
unity3d：使用math.net
06-08
在Unity3D中使用Math.NET Numerics可以帮助我们更方便地实现各种数学计算和处理，例如计算向量、矩阵、解方程组、拟合曲线等。 使用Math.NET Numerics的步骤如下： 1. 下载并导入Math.NET Numerics的Unity3D插件。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值