nav[aria-label="Primary Navigation"] { padding: 0; & ul { list-style: none; width: 100%; display: flex; flex-direction: row; justify-content: start; align-items: start; gap: 30px; padding: 0; & li { margin: 0; } & ul li { list-style: none; } } }

920180_ko-KR

liliconcom

레이 마칭과 웹P

이 글에서는 레이 마칭을 수행하는 너무 느린 방법과 파이썬을 사용하여 애니메이션 WebP(애니메이션 GIF와 비슷하지만 훨씬 보기 좋습니다!)를 만드는 완벽한 방법을 보여줍니다.

파트 1: 파일 형식

이 JSL 스크립트는 Python PIL 라이브러리를 사용하여 PNG , JPEG , 웹P 파일의 크기, 속도 및 품질을 비교하는 테스트 파일을 생성합니다. GIF 파일 은 2부에 있습니다. 실행하려면 두 번째 줄에 0 또는 1을 입력하여 각 이미지를 생성하세요. RMSE 값은 디코딩된 픽셀의 평균 오차에서 원본 픽셀의 평균 오차를 뺀 값으로, 0~255 색상 채널 단위로 표시됩니다. 압축률이 높을수록 오차가 커지며, 이로 인해 고도로 압축된 이미지에서 아티팩트나 흐릿함이 발생합니다. PNG 이미지는 무손실 압축을 사용하여 RMSE 값이 0.0이 됩니다.

보라색 WebP 점은 거의 모든 압축률에서 빨간색 JPEG 점보다 RMSE 값이 일관적으로 낮습니다. 또한 압축하는 데 약 20배 더 오래 걸리지만, 이미지를 영구적으로 저장할 경우 그럴 만한 가치가 있을 수 있습니다.

{picLeft, picRight, picTop, picBottom} = If( 1,
	picURL = "https://upload.wikimedia.org/wikipedia/commons/1/1e/Rooster_-_Public_Domain.jpg"; // Lisafern, CC0, via Wikimedia Commons -- https://commons.wikimedia.org/wiki/Special:ListFiles/lisafern
	{600000, 6000000, 35, 5};//
, //
	picURL = "https://upload.wikimedia.org/wikipedia/commons/3/3a/Foster_graph_hamiltonian.png"; // public domain: https://commons.wikimedia.org/wiki/File:Foster_graph_hamiltonian.png
	{450000, 10000000, 32, 8};//
);
gTempFiles = Convert File Path( "$temp\pil_webp\", "windows" );
Delete Directory( gTempFiles ); // careful!
Create Directory( gTempFiles ); // the directory exists, and is empty

// load python and make sure PIL is available...
rc = Python Execute(
	{},
	{},
	"\[from PIL import Image, ImageSequence
import numpy as np
import os
import time
def rmse(imageA, imageB):
    if imageA.size != imageB.size:
        raise ValueError("Images must have the same dimensions to calculate RMSE")
    imgA_np = np.asarray(imageA).astype("float")
    imgB_np = np.asarray(imageB).astype("float")
    err = np.sum((imgA_np - imgB_np) ** 2)
    err /= float(imageA.size[0] * imageA.size[1])
    return np.sqrt(err)
]\",
	echo( 0 )
);
If( rc != 0,
	Throw( "python init error rc=" || Char( rc ) ),
	"ok"
);

// add a JSL image to a list of files for a .webp and .jpg and .gif
addNewFrame = Function( {filename, img},
	img << saveimage( gTempFiles || filename || ".png", "png" ); // png is lossless and the rmse uses this for comparison
	File Size( gTempFiles || filename || ".png" );
);

// the saveFrameTo... and saveFramesTo... functions 
// reflect the way the formats are typically used;
// you would not normally make a single frame GIF
// and you can't really make a multi-frame JPG.

saveFrameToWebP = Function( {outputfilename, qual},
	{filelist, webpname, rc}, //
	filelist = Transform Each( {f}, Files In Directory( gTempFiles ), //
		Convert File Path( gTempFiles || f, "windows" );//
	);
	If( N Items( filelist ) != 1, //
		Throw( "saveFrameToWebP nitems=" || Char( N Items( filelist ) ) );//
	);
	webpname = Convert File Path( outputfilename, "windows" );
	rc = Python Execute(
		{filelist, webpname, qual}, // inputs
		{_rmse, _ossize, _timew, _timer}, // outputs
		"\[# https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#webp
imgs = []
for f in filelist:
    imgs.append(Image.open(f).convert('RGB'))
img=imgs[0]
_timew = time.perf_counter()
img.save(webpname,save_all=True,format="WEBP",
    minimize_size=True,
    lossless=False,quality=int(qual))
_timew = time.perf_counter() - _timew
_timer = time.perf_counter()
ir = Image.open(webpname).convert('RGB')
_timer = time.perf_counter() - _timer
_rmse = rmse(img,ir)
_ossize = os.path.getsize(webpname)
imgs = None
]\",
		echo( 0 )
	);
	If( rc != 0, //
		Throw( "saveFrameToWebP error rc=" || Char( rc ) );//
	, //
		Eval List( {_rmse, _ossize, _timew, _timer} );// return value
	);
);

saveFrameToPng = Function( {outputfilename, qual},
	{filelist, pngname, rc}, //
	filelist = Transform Each( {f}, Files In Directory( gTempFiles ), //
		Convert File Path( gTempFiles || f, "windows" );//
	);
	If( N Items( filelist ) != 1, //
		Throw( "saveFrameToPng nitems=" || Char( N Items( filelist ) ) );//
	);
	pngname = Convert File Path( outputfilename, "windows" );
	rc = Python Execute(
		{filelist, pngname, qual}, // inputs
		{_rmse, _ossize, _timew, _timer}, // outputs
		"\[# 
imgs = []
for f in filelist:
    imgs.append(Image.open(f).convert('RGB'))
img=imgs[0]
_timew = time.perf_counter()
img.save(pngname,save_all=True,format="PNG",
    optimize=True,
    quality=int(qual))
_timew = time.perf_counter() - _timew
_timer = time.perf_counter()
ir = Image.open(pngname).convert('RGB')
_timer = time.perf_counter() - _timer
_rmse = rmse(img,ir)
_ossize = os.path.getsize(pngname)
imgs = None
]\",
		echo( 0 )
	);
	If( rc != 0, //
		Throw( "saveFrameToWebP error rc=" || Char( rc ) );//
	, //
		Eval List( {_rmse, _ossize, _timew, _timer} );// return value
	);
);

saveFrameToJPG = Function( {outputfilename, qual},
	{filelist, jpgname, rc}, //
	filelist = Transform Each( {f}, Files In Directory( gTempFiles ), //
		Convert File Path( gTempFiles || f, "windows" );//
	);
	If( N Items( filelist ) != 1, //
		Throw( "saveFrameToJPG nitems=" || Char( N Items( filelist ) ) );//
	);
	jpgname = Convert File Path( outputfilename, "windows" );
	rc = Python Execute(
		{filelist, jpgname, qual}, // inputs
		{_rmse, _ossize, _timew, _timer}, // outputs
		"\[# https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#webp
imgs = []
for f in filelist:
    imgs.append(Image.open(f).convert('RGB'))
img=imgs[0]
_timew = time.perf_counter()
img.save(jpgname,format="JPEG",
    optimize=True,
    quality=int(qual))
_timew = time.perf_counter() - _timew
_timer = time.perf_counter()
ir = Image.open(jpgname).convert('RGB')
_timer = time.perf_counter() - _timer
_rmse = rmse(img,ir)
_ossize = os.path.getsize(jpgname)
imgs = None
]\",
		echo( 0 )
	);
	If( rc != 0, //
		Throw( "saveFrameToJPG error rc=" || Char( rc ) );//
	, //
		Eval List( {_rmse, _ossize, _timew, _timer} );// return value
	);
);

// Lisafern, CC0, via Wikimedia Commons -- https://commons.wikimedia.org/wiki/Special:ListFiles/lisafern
img = New Image( picURL );
start = HP Time();
pngSize1 = addNewFrame( "1jsl.png", img );
JSLpngTime = (HP Time() - start) / 1e6;
dt = New Table( //
	New Column( "extension", "character" ),
	New Column( "size" ),
	New Column( "timewrite" ),
	New Column( "timeread" ),
	New Column( "rmse" )
);

dt << addrows( 1 );
extension = "JSLPng";
size = pngSize1;
rmse = 0;
timewrite = JSLpngTime;

dt << addrows( 1 );
extension = "PILPng";
{rmse, size, timewrite, timeread} = saveFrameToPng( "$temp/1.png", 95 );

For( i = 0, i <= 100, i += 1,
	dt << addrows( 1 );
	extension = "WebP";
	{rmse, size, timewrite, timeread} = saveFrameToWebP( "$temp/1.webp", i );
	Wait( .01 );
	dt << addrows( 1 );
	extension = "Jpg";
	{rmse, size, timewrite, timeread} = saveFrameToJpg( "$temp/1.jpg", i );
	Wait( .01 );
);


dt << Graph Builder(
	Size( 996, 713 ),
	Show Control Panel( 0 ),
	Legend Position( "Inside Floating" ),
	Variables( X( :size ), Y( :rmse ), Overlay( :extension ), Size( :timewrite ) ),
	Elements( Points( X, Y, Legend( 47 ) ) ),
	SendToReport(
		Dispatch( {}, "size", ScaleBox,
			{Scale( "Log" ), Format( "Engineering SI", 12 ), Min( 1e4 ), Max( 6.1e6 ), Minor Ticks( 1 ), Label Row(
				{Show Major Grid( 1 ), Show Minor Grid( 1 ), Show Minor Labels( 1 )}
			)}
		),
		Dispatch( {}, "rmse", ScaleBox, {Min( -0.5 ), Max( 32 ), Inc( 5 ), Minor Ticks( 0 )} ),
		Dispatch( {}, "400", ScaleBox,
			{Legend Model(
				47,
				Type Properties( 0, "Marker", {Marker( "FilledCircle" )} ),
				Properties( 1, {Line Color( 3 ), Marker( "FilledCircle" )}, Item ID( "Jpg", 1 ) ),
				Properties( 2, {Line Color( 5 ), Marker( "FilledCircle" )}, Item ID( "JSLPng", 1 ) ),
				Properties( 3, {Line Color( 6 ), Marker( "FilledCircle" )}, Item ID( "PILPng", 1 ) ),
				Properties( 4, {Line Color( 8 ), Marker( "FilledCircle" )}, Item ID( "WebP", 1 ) ),
				Properties( -1, {Marker( "FilledSquare" )}, Item ID( "Png", 1 ) )
			)}
		),
		Dispatch( {}, "graph title", TextEditBox, {Set Text( "WebP vs Jpg vs Png" )} ),
		Dispatch( {}, "size", TextEditBox, {Set Text( "Size on disk, bytes" )} ),
		Dispatch( {}, "rmse", TextEditBox, {Set Text( "RMSE out of 255" )} ),
		Dispatch( {}, "Graph Builder", FrameBox,
			{Marker Drawing Mode( "Normal" ), Reference Line Order( 6 ), Add Image(
				2, // layer 2 above grid lines
				image( New Image( picURL ) ),
				Bounds( Left( picLeft ), Right( picRight ), Top( picTop ), Bottom( picBottom ) )
			), Add Graphics Script( 7, Description( "" ), Empty() )}
		),
		Dispatch( {}, "400", LegendBox, {Legend Position( {47, [4, 0, 3, 2, 1]} )} )
	)
);

dt << Graph Builder(
	Size( 638, 370 ),
	Show Control Panel( 0 ),
	Variables( X( :size ), Y( :timeread ), Overlay( :extension ) ),
	Elements( Points( X, Y, Legend( 9 ) ) ),
	SendToReport(
		Dispatch( {}, "400", ScaleBox,
			{Legend Model(
				9,
				Properties( 0, {Line Color( 3 )}, Item ID( "Jpg", 1 ) ),
				Properties( 1, {Line Color( 5 )}, Item ID( "JSLPng", 1 ) ),
				Properties( 2, {Line Color( 6 )}, Item ID( "PILPng", 1 ) ),
				Properties( 3, {Line Color( 8 )}, Item ID( "WebP", 1 ) )
			)}
		),
		Dispatch( {}, "400", LegendBox, {Legend Position( {9, [0, 3, 2, 1]} )} )
	)
);

{picLeft, picRight, picTop, picBottom} = If( 1, picURL = "https://upload.wikimedia.org/wikipedia/commons/1/1e/Rooster_-_Public_Domain.jpg"; // Lisafern, CC0, via Wikimedia Commons -- https://commons.wikimedia.org/wiki/Special:ListFiles/lisafern {600000, 6000000, 35, 5};// , // picURL = "https://upload.wikimedia.org/wikipedia/commons/3/3a/Foster_graph_hamiltonian.png"; // public domain: https://commons.wikimedia.org/wiki/File:Foster_graph_hamiltonian.png {450000, 10000000, 32, 8};// ); gTempFiles = Convert File Path( "$temp\pil_webp\", "windows" ); Delete Directory( gTempFiles ); // 주의! Create Directory( gTempFiles ); // 디렉터리가 존재하고 비어 있습니다. // Python을 로드하고 PIL이 사용 가능한지 확인합니다. rc = Python Execute( {}, {}, "\[from PIL import Image, ImageSequence import numpy as np import os import time def rmse(imageA, imageB): if imageA.size != imageB.size: raise ValueError("RMSE를 계산하려면 이미지의 크기가 같아야 합니다.") imgA_np = np.asarray(imageA).astype("float") imgB_np = np.asarray(imageB).astype("float") err = np.sum((imgA_np - imgB_np) ** 2) err /= float(imageA.size[0] * imageA.size[1]) return np.sqrt(err) ]\", echo( 0 ) ); If( rc != 0, Throw( "python init error rc=" || Char( rc ) ), "ok" ); // .webp, .jpg, .gif 파일 목록에 JSL 이미지를 추가합니다. addNewFrame = Function( {filename, img}, img << saveimage( gTempFiles || filename || ".png", "png" ); // png는 무손실 포맷이며 rmse는 이를 비교에 사용합니다. File Size( gTempFiles || filename || ".png" ); ); // saveFrameTo... 및 saveFramesTo... 함수는 // 일반적으로 포맷이 사용되는 방식을 반영합니다. // 일반적으로 단일 프레임 GIF를 만들지는 않으며 // 다중 프레임 JPG는 사실상 만들 수 없습니다. saveFrameToWebP = Function( {outputfilename, qual}, {filelist, webpname, rc}, // filelist = Transform Each( {f}, Files In Directory( gTempFiles ), // Convert File Path( gTempFiles || f, "windows" );// ); If( N Items( filelist ) != 1, // Throw( "saveFrameToWebP nitems=" || Char( N Items( filelist ) ) );// ); webpname = Convert File Path( outputfilename, "windows" ); rc = Python Execute( {filelist, webpname, qual}, // inputs {_rmse, _ossize, _timew, _timer}, // outputs "\[# https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#webp imgs = [] for f in filelist: imgs.append(Image.open(f).convert('RGB')) img=imgs[0] _timew = time.perf_counter() img.save(webpname,save_all=True,format="WEBP", minimize_size=True, lossless=False,quality=int(qual)) _timew = time.perf_counter() - _timew _timer = time.perf_counter() ir = Image.open(webpname).convert('RGB') _timer = time.perf_counter() - _timer _rmse = rmse(img,ir) _ossize = os.path.getsize(webpname) imgs = None ]\", echo( 0 ) ); If( rc != 0, // Throw( "saveFrameToWebP 오류 rc=" || Char( rc ) );// , // 평가 List( {_rmse, _ossize, _timew, _timer} );// 반환 값 ); ); saveFrameToPng = Function( {outputfilename, qual}, {filelist, pngname, rc}, // filelist = Transform Each( {f}, Files In Directory( gTempFiles ), // Convert File Path( gTempFiles || f, "windows" );// ); If( N Items( filelist ) != 1, // Throw( "saveFrameToPng nitems=" || Char( N Items( filelist ) ) );// ); pngname = Convert File Path( outputfilename, "windows" ); rc = Python Execute( {filelist, pngname, qual}, // inputs {_rmse, _ossize, _timew, _timer}, // outputs "\[# imgs = [] for f in filelist: imgs.append(Image.open(f).convert('RGB')) img=imgs[0] _timew = time.perf_counter() img.save(pngname, save_all=True, format="PNG", optimize=True, quality=int(qual)) _timew = time.perf_counter() - _timew _timer = time.perf_counter() ir = Image.open(pngname).convert('RGB') _timer = time.perf_counter() - _timer _rmse = rmse(img, ir) _ossize = os.path.getsize(pngname) imgs = None ]\", echo( 0 ) ); If( rc != 0, // Throw( "saveFrameToWebP 오류 rc=" || Char( rc ) );// , // Eval List( {_rmse, _ossize, _timew, _timer} );// 반환 값 ); ); saveFrameToJPG = Function( {outputfilename, qual}, {filelist, jpgname, rc}, // filelist = Transform Each( {f}, Files In Directory( gTempFiles ), // Convert File Path( gTempFiles || f, "windows" );// ); If( N Items( filelist ) != 1, // Throw( "saveFrameToJPG nitems=" || Char( N Items( filelist ) ) );// ); jpgname = Convert File Path( outputfilename, "windows" ); rc = Python Execute( {filelist, jpgname, qual}, // inputs {_rmse, _ossize, _timew, _timer}, // outputs "\[# https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#webp imgs = [] for f in filelist: imgs.append(Image.open(f).convert('RGB')) img=imgs[0] _timew = time.perf_counter() img.save(jpgname,format="JPEG", optimize=True, quality=int(qual)) _timew = time.perf_counter() - _timew _timer = time.perf_counter() ir = Image.open(jpgname).convert('RGB') _timer = time.perf_counter() - _timer _rmse = rmse(img,ir) _ossize = os.path.getsize(jpgname) imgs = None ]\", echo( 0 ) ); If( rc != 0, // Throw( "saveFrameToJPG 오류 rc=" || Char( rc ) );// , // Eval List( {_rmse, _ossize, _timew, _timer} );// 반환 값 ); ); // Lisafern, CC0, Wikimedia Commons 제공 -- https://commons.wikimedia.org/wiki/Special:ListFiles/lisafern img = New Image( picURL ); start = HP Time(); pngSize1 = addNewFrame( "1jsl.png", img ); JSLpngTime = (HP Time() - start) / 1e6; dt = New Table( // New Column( "extension", "character" ), New Column( "size" ), New Column( "timewrite" ), New Column( "timeread" ), New Column( "rmse" ) ); dt << addrows( 1 ); extension = "JSLPng"; size = pngSize1; rmse = 0; timewrite = JSLpngTime; dt << addrows( 1 ); extension = "PILPng"; {rmse, size, timewrite, timeread} = saveFrameToPng( "$temp/1.png", 95 ); For( i = 0, i <= 100, i += 1, dt << addrows( 1 ); extension = "WebP"; {rmse, size, timewrite, timeread} = saveFrameToWebP( "$temp/1.webp", i ); Wait( .01 ); dt << addrows( 1 ); extension = "Jpg"; {rmse, size, timewrite, timeread} = saveFrameToJpg( "$temp/1.jpg", i ); Wait( .01 ); ); dt << 그래프 빌더( 크기( 996, 713 ), 제어판 표시( 0 ), 범례 위치( "부유 영역 내부" ), 변수( X( :size ), Y( :rmse ), 오버레이( :extension ), 크기( :timewrite ) ), 요소( 점( X, Y, 범례( 47 ) ) ), 보고서 전송( 디스패치( {}, "size", 스케일 박스, {스케일( "로그" ), 형식( "엔지니어링 SI", 12 ), 최소값( 1e4 ), 최대값( 6.1e6 ), 보조 눈금( 1 ), 레이블 행( {주요 그리드 표시( 1 ), 보조 그리드 표시( 1 ), 보조 레이블 표시( 1 )} )} ), 디스패치( {}, "rmse", 스케일 박스, {최소값( -0.5 ), 최대값( 32 ), 증가( 5 ), 보조 Ticks( 0 )} ), Dispatch( {}, "400", ScaleBox, {Legend Model( 47, Type Properties( 0, "Marker", {Marker( "FilledCircle" )} ), Properties( 1, {Line Color( 3 ), Marker( "FilledCircle" )}, Item ID( "Jpg", 1 ) ), Properties( 2, {Line Color( 5 ), Marker( "FilledCircle" )}, Item ID( "JSLPng", 1 ) ), Properties( 3, {Line Color( 6 ), Marker( "FilledCircle" )}, Item ID( "PILPng", 1 ) ), Properties( 4, {Line Color( 8 ), Marker( "FilledCircle" )}, Item ID( "WebP", 1 ) ), Properties( -1, {Marker( "FilledSquare" )}, 항목 ID( "Png", 1 ) ) )} ), Dispatch( {}, "그래프 제목", TextEditBox, {Set Text( "WebP vs Jpg vs Png" )} ), Dispatch( {}, "크기", TextEditBox, {Set Text( "디스크 크기, 바이트" )} ), Dispatch( {}, "rmse", TextEditBox, {Set Text( "RMSE out of 255" )} ), Dispatch( {}, "그래프 빌더", FrameBox, {마커 그리기 모드( "일반" ), 참조선 순서( 6 ), 이미지 추가( 2, // 그리드 선 위 레이어 2 이미지( 새 이미지( picURL ) ), 경계( 왼쪽( picLeft ), 오른쪽( picRight ), 위쪽( picTop ), 아래쪽( picBottom ) ) ), 그래픽 스크립트 추가( 7, 설명( "" ), Empty() )} ), Dispatch( {}, "400", LegendBox, {Legend Position( {47, [4, 0, 3, 2, 1]} )} ) ) ); dt << Graph Builder( Size( 638, 370 ), Show Control Panel( 0 ), Variables( X( :size ), Y( :timeread ), Overlay( :extension ) ), Elements( Points( X, Y, Legend( 9 ) ) ), SendToReport( Dispatch( {}, "400", ScaleBox, {Legend Model( 9, Properties( 0, {Line Color( 3 )}, Item ID( "Jpg", 1 ) ), Properties( 1, {Line Color( 5 )}, Item ID( "JSLPng", 1 ) ), Properties( 2, {Line Color( 6 )}, Item ID( "PILPng", 1 ) ), Properties( 3, {Line Color( 8 )}, Item ID( "WebP", 1 ) ) )} ), Dispatch( {}, "400", 범례 상자, {범례 위치( {9, [0, 3, 2, 1]} )} ) ) );

실제 이미지를 저장하는 예시입니다. 3MB 디스크 용량을 초과하는 주황색과 파란색 점들은 PNG 파일이 이 데이터를 제대로 압축하지 못하는 것을 보여줍니다. 원본 이미지 는 1264x2208 픽셀, 즉 2,790,912픽셀이며, 각 픽셀은 압축되지 않은 상태에서 3바이트입니다. 거의 모든 파일 크기에서 WebP는 동일한 크기의 JPEG보다 RMSE가 작아(더 나은 화질) 좋지만, 압축 시간(마커 크기)은 훨씬 더 큽니다.

선명한 컴퓨터 이미지를 저장하는 방법입니다. 이 데이터의 경우, 최상의 이미지 품질을 위해서는 PNG가 JPG보다 우수합니다. 하지만 대부분의 사용자는 두 이미지 유형 모두 RMSE 값이 5 미만이면 만족할 것입니다. 원본 이미지 는 2000x2000 픽셀, 즉 400만 픽셀이며, 각 픽셀은 압축되지 않은 상태에서 3바이트입니다. 마찬가지로 WebP는 동일한 크기의 JPEG보다 품질이 높지만 압축하는 데 시간이 더 오래 걸립니다.

다음은 읽기 시간 비교입니다. 이 시간은 파이썬의 PIL 리더에만 해당하며, Firefox나 이미지를 표시하는 다른 브라우저에는 적용되지 않습니다. WebP는 JPEG보다 로딩 속도가 3배 느린 것으로 보입니다.

WebP, JPEG, PNG 중 어느 것도 확실한 승자는 아닙니다(아직은). JPEG는 압축 속도가 빠르고, WebP는 압축률이 낮으며, PNG는 무손실 압축입니다. 개인적으로는 대부분의 컴퓨터 생성 그래프에는 PNG를 사용하고 (적어도 과거에는) 실제 이미지에는 JPEG를 사용했습니다. JMP 19는 Python을 사용하지 않고는 WebP 이미지 형식을 지원하지 않습니다.

파트 2: 애니메이션 파일 형식

WebP와 GIF 형식 모두 여러 이미지를 저장하고 소리 없이 반복 재생할 수 있습니다. JMP는 애니메이션 GIF를 직접 생성할 수 있으며, Python과 PIL을 사용하면 애니메이션 WebP도 생성할 수 있습니다. 최신 기술인 WebP는 오래된 GIF 기술보다 훨씬 뛰어납니다. 마지막에 있는 두 이미지를 참조하세요.

몇 년 전, 저는 우연히 https://www.shadertoy.com/ 이라는 사이트를 발견했습니다. (절대 찾아보지 마세요, 한동안 돌아오지 못할지도 몰라요!) 셰이더는 그래픽 카드(GPU)에서 실행되는 아주 작은 프로그램입니다. 디스플레이의 각 픽셀은 셰이더 프로그램의 출력에 따라 색이 입혀집니다. GPU가 많을수록 더 많은 픽셀을 더 빠르게 생성합니다. 이 사이트가 흥미로운 이유는 C 언어와 비슷한 셰이더 프로그램을 수정하고 브라우저에서 다시 실행할 수 있기 때문입니다. 브라우저가 GPU에 접근할 수 있고, 그 속도는 정말 빠릅니다.

셰이더는 원래 3D 삼각형을 색칠하기 위해 고안되었으며, 각 꼭짓점은 재질, 방향, 조명 등에 따라 고유한 색상을 갖습니다. 삼각형의 픽셀(일반적으로 프래그먼트라고 함)은 꼭짓점 사이에서 보간됩니다. 그러나 셰이더가 반드시 3D 삼각형을 사용해야 하는 것은 아니며, 원하는 방식으로 색상을 계산할 수 있습니다. Shadertoy의 일부 예제는 xy 픽셀 좌표와 현재 시간을 기반으로 색상을 계산하여 바다의 파도와 같은 움직임을 애니메이션으로 구현합니다.

더 흥미로운 예시들은 레이 마칭(ray marching)이라는 개념을 사용합니다. 레이 마칭과 부호 거리 함수(SDF)에 대한 훌륭한 튜토리얼들이 많이 있습니다. (SDF는 객체의 표면에서 점까지의 거리가 양수이고, 점이 객체 내부로 들어간 경우에는 음수입니다.) 간단히 말해서, 레이 마칭은 눈/카메라 앞에 픽셀로 이루어진 가상의 화면을 놓고, 눈에서 시작하여 각 픽셀을 통과하는 광선을 따라 여러 개의 부호 거리 함수에 도달하게 합니다. 각 SDF에 "광선 상의 이 점은 눈에서 얼마나 떨어져 있습니까?"라고 묻습니다. 구, 정육면체, 토러스, 평면 등은 모두 간단한 SDF를 가지고 있습니다. 레이 마칭의 핵심은 모든 SDF 중에서 최소값을 찾아 그 거리만큼 광선을 따라 이동하는 과정을 최소 거리가 매우 작아질 때까지 반복하는 것입니다. 일반적으로 각 픽셀에 SDF로 표현된 객체에 접근하려면 수십 번의 반복이 필요합니다. 같은 방식으로 SDF 상의 점이 그림자에 가려져 있는지, 표면의 기울기(눈으로 반사되는 빛의 양을 결정함)도 파악할 수 있습니다.

다음은 카메라가 움직이는 3D 모델에서 애니메이션 GIF와 애니메이션 WebP를 생성하는 JSL 코드입니다. 코드의 대부분은 레이 마칭 관련 내용이지만, 실제로는 필요하지 않습니다. 필요한 함수는 `addNewFrame`과 `saveFrames`입니다. `addNewFrame`은 전역 변수 `bitmap`에서 지정된 디렉터리에 파일을 생성하고, `saveFrames`는 디렉터리의 모든 파일을 가져와 WebP 또는 GIF를 생성합니다. 필요에 따라 이 함수들을 수정하면 됩니다. 나머지 코드는 레이 마칭에 특화된 내용이며, (속도가 느리기 때문에) 실용적이라기보다는 교육적인 목적이 더 큽니다.

start = HP Time();

xypix = 512;//32 takes 22s/f; 256 takes 22 minutes/frame, 128 is 6 min/fr
nframes=128;
ambient=.0005; // .0001 barely visible
lightPosition = -40. || -40. || 0; // top left. z=0 is near eye, -1 closer to scene. 
lightPower = 50;
filesdir="$desktop/donutpics/"; // not empty()! 
makegif = "$desktop/donut.gif"; // empty() or "$desktop/filename.gif"
makewebp = "$desktop/donut.webp"; // empty() or "$desktop/filename.webp" -- requires jpip.bat install Pillow
//deletedirectory(filesdir);createdirectory(filesdir);
if(!Directory Exists(filesdir),throw("stopped because directory does not exist: "||filesdir));
if(nitems(filesindirectory(filesdir))!=0,throw("stopped because directory not empty: "||filesdir));

if(!isempty(makewebp), // need a snip of python to make webp...fail early if not there
	rc = Python Execute({},{},
"\[from PIL import Image
]\",echo(0));
	if(rc!=0, throw("python init error rc="||char(rc)),"ok");
);

addNewFrame = Function( {filename},{img}, // writes global bitmap to filesdir in .png format
	img = New Image( bitmap );
	img<
        <SAVEIMAGE>
         51 bits of integer available. cscale = 2 ^ 17;// 3*17==51bits in 52-53bit double. sign bit is also used elsewhere. cscaleMax = 2 ^ 3;// biggest rgb packcolor handles // packcolor is inside the parallel assign to build 17 bit per color doubles; the // >8 bit per color resolution helps delay the scaling without loss of color. // unpackcolor is needed after the parallelassign. unpackcolor = Function( {pc}, {r, g, b}, r = Mod( pc, cscale ) / (cscale / cscaleMax - 1); pc = Floor( pc / cscale ); g = Mod( pc, cscale ) / (cscale / cscaleMax - 1); pc = Floor( pc / cscale ); b = Mod( pc, cscale ) / (cscale / cscaleMax - 1); Eval List( {r, g, b} ); ); finalImage=0; // a flag to recreate the animated gif // if you are going to use this for more than a simple gif-loop, // you could repackage this. For now it uses an "time" from 0 to 1 // to make a complete orbit of the camera. Shadertoy uses time "t" // and makes an angle from that; shadertoy is not typically making // a loop for a gif, but rather a mouse driven display. // using a power of 2 is not required for the step but does make the // begin and end match up; the <1.0 means the end frame is left out. for(time=0.0,time<1.0,time+=1/nframes, // y rotation (vertical on screen) is done over the angles. then // a small tilt on X to make the camera look down at the tiled floor. // then the camera is pulled back so the scene, which is near 0,0,0 // will be in view. Back means the Z axis; the wording around this // is always confusing! angle = time*2*pi(); anim_8=8*angle; anim_7=7*angle; anim_3=3*angle; anim_1=1*angle; camera = tranmat(0,0,-8)*getXrot(-.1 *2*pi()+0.06*sin(anim_1))*getYrot(anim_1); // the scene list is a list of lists... and the lists must be evaluated to store an efficient value. scene = Eval List( { // tranmat: Y positive down screen, z positive toward camera Eval List( {"torus", Expr( ptrep = pt[1]-12*round(pt[1]/12)||pt[2]-12*round(pt[2]/12)||pt[3]; // repeat the torus on the X and Z axis (rotated onto Y) https://iquilezles.org/articles/sdfrepetition/ sdTorus( ptrep, [2 1] ); ), Eval List( {"solid", RGB Color( "white" )} ), // Inverse( scalemat( 1, 1, 1 ) * tranmat( 0, 1/*down to the floor*/, 0 ) * rotmat(90,0,0))} ), // Eval List( {"floor", Expr( sdPlane( pt, [0 -1 0], 2.1 ) ), Eval List( {"checker", RGB Color( "green" )} ), // Identity( 4 )} )// } ); nspheres = 11;// add n bouncing spheres in a circle. the Y axis anim8 + p0 phases the bounces for( p=0,p
         <NSPHERES>
          maxt,i=1e99/*break*/ ); ); res = max(res,-1.0); 0.25*(1.0+res)*(1.0+res)*(2.0-res); ), // https://github.com/scratchapixel/scratchapixel-code/blob/main/perspective-and-orthographic-projection-matrix/geometry.h dotProduct = Function( {a, b}, // v2 or v3 x * v.x + y * v.y + z * v.z Sum( a :* b ) // scalar: how much the vecs a and b point in the same direction ), crossProduct = Function( {a, b}, // v3 only y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x a[2] * b[3] - a[3] * b[2] || a[3] * b[1] - a[1] * b[3] || a[1] * b[2] - a[2] * b[1]; // vector: perpendicular to both a and b ), // https://www.shadertoy.com/view/4dSBz3 and https://iquilezles.org/articles/normalsSDF/ // Calculate the normal by taking the central differences on the distance field. // for spheres there is a simpler way, probably torus too. And plane! // I'm keeping the code simple for now. // https://iquilezles.org/articles/normalsSDF/ - tetrahedron technique calcNormal = Function( {p}, p = p[1] || p[2] || p[3]; normalize( // this is a tetrahedron around p [1 -1 -1] * map( p + [.001 -.001 -.001] ) + // [-1 -1 1] * map( p + [-.001 -.001 .001] ) + // [-1 1 -1] * map( p + [-.001 .001 -.001] ) + // [1. 1 1.] * map( p + [.0010 .001 .0010] ) // ); // ), // mapFound = ., // global to remember what object the march ran into. // the map function tests p against every object in scene and returns the closest. map = Function( {p}, {i, result, tresult, pt}, p = p[1] |/ p[2] |/ p[3] |/ 1; result = 1e99; mapFound = .; For( i = 1, i <= N Items( scene ), i += 1, pt = scene[i][sceneDistanceMatrix] * p; // the torus rotate on X happens before the repeat operation, so the Z axis is Y. pt = pt[1] || pt[2] || pt[3]; tresult = Eval( scene[i][sceneDistanceExpr] ); If( tresult < result, result = tresult; mapFound = i; // remember. Not needed on majority of calls. ); ); result; ), // // // the scene list. the sceneDistanceExpr expr() should only use // functions that are in the parallel assign locals! // // first some indexes that explain how to interpret the scene list sceneDistanceName = 1, // sceneDistanceExpr = 2, // sceneDistanceMaterial = 3, // /**/sceneDistanceMaterial_pattern = 1, // /**/sceneDistanceMaterial_color = 2, // sceneDistanceMatrix = 4, // lightPosition=lightPosition, // lightPower=lightPower, // // no comma at end... scene=scene // }, // locals for each thread // // finally, the JSL that assigns elements of the array. Parallel Assign has // already chosen an element and supplies a scaled index; the .68 scale was // empirically chosen to look good. we cannot access the bitmap we are assigning // into from here, not even the old value about to be overwritten (a bug/flaw // in the implementation...we could use a copy of course). // bitmap[yImage( -.68, .68 ), xImage( -.68, .68 )] = (// // here begins pretty standard ray marching code; better to look up excellent explanations on the web. ro = 0 || 0 || 1 ; // ray origin at 0,0 this eye is 1 unit in front of the image plane at z=0 rd = (xImage || yImage || 0) - ro ; // ray direction, image plane is one z unit from the eye_origin rd = normalize( rd ) ; //normalize to length 1 t = 1 ; resultColor = -1 ; // background if nothing hit For( i = 0, i < 1024 & t < 1024, i += 1, // <512 is iteration limit, <200 is depth limit for nothing in background p = ro + rd * t; pi = invCamera * (p || 1)`; h = map( pi ); t += h; If( h < .001, object = mapFound; // capture before calcNormal reuses map() light = lightPosition; if(0,// 1: light attached to camera (needs work) light = invCamera * (light || 1)`; // light relative to camera light = light[[1 2 3]]`; ); // https://www.shadertoy.com/view/4dSBz3 ... // Calculate diffuse lighting by taking the dot product of // the light direction (light-p) and the normalVec. lightVec = normalize( light - pi[[1 2 3]]` /*p*/ ); normalVec = calcNormal( pi[[1 2 3]]` ); dif = clamp( dotProduct( normalVec, lightVec ), 0., 1. ); dif *= softShadow(pi,lightVec, .02/*min t*/, 30/*max t*/, .1/*width of light*/); // <<<< leave this out, get no shadows and a big speedup // Multiply by light intensity and divide by the square of the distance to the light. // a post processing step will tweak the lighting to get at least one bright pixel in some color. // if there is blow-out (light too bright) or banding (light too dark), adjust 1e0 up or down dif *= lightPower / dotProduct( light - p, light - p ); // 1e-5 ... 1e5 dif += ambient; // add a little ambient. For an early test case, .0001 kept shadows from going completely black. // https://iquilezles.org/articles/checkerfiltering/ not using his algorithm, rolled my own... If( scene[object][sceneDistanceMaterial][sceneDistanceMaterial_pattern] == "checker", // t is the distance to this object with the checker pattern. // as t gets bigger, the pattern should be less visible // amplitude is the product of the x and y axis sin waves and forms the tiles; *5 // makes the tile size (bigger makes smaller tiles.) Even raised to ^.4 power there // is some slope at the transition between tiles. bigdiv is a number between 1 and 2 // with the slope for the transition; smalldiv is always 1. divisor is interpolated // between smalldiv and bigdiv; t is the distance and chooses smalldiv when the floor is // far away, bigdiv up close. Smalldiv picks the middle value between the light and dark // tile color. Bigdiv makes dark darker and light lighter. Far away tiles are the average color, // and near the tile transitions are the average color and the result is somewhat anti-aliased. amplitude = sin(pi[1]*5) * sin(pi[3]*5); // 1,3 is the x-z plane the floor lies in <<< unfortunate, we have to know this is the floor. bigdiv = 1+abs(amplitude)^.4; // empirically, I like .4 better than .3 or .5 smalldiv=1; // empirical: the useful z-distance before aliasing happens. Formula from fit model. // 32x32 13 // 128x128 26 // 512x512 52 //zdistance = (-42.25) + 9.75 * log(xypix,2) + 1.625 * (log(xypix,2) - 7) * (log(xypix,2) - 7); divisor = interpolate(t, -1e99,bigdiv, 3,bigdiv, zdistance,smalldiv, 1e99,smalldiv); if(amplitude > 0, dif /= divisor; // , // dif *= divisor; // ) ); resultColor = Max( dif, 0 ); resultColor = resultColor ^ 0.4545; // Gamma correction, not sure where it comes from but several sources use .4545 i = 1e99; /* break */ ); ); If( resultColor < 0, // If( resultColor != -1, Show( resultColor ) ); // background, most likely RGB Color( .4, .5, .6 );// a JSL color is negative , /*else if */ Is Missing( resultColor ), // RGB Color( .8, .1, .8 )// error color, negative jsl color , // else a positive packed color, up to 3 bits of int and 14 bits fraction {red, green, blue} = Color To RGB( scene[object][sceneDistanceMaterial][sceneDistanceMaterial_color] ); packcolor( red * resultColor, green * resultColor, blue * resultColor ) // ; ) ; // ); // bitmap= expr );//ParallelAssign // there are two kinds of values in the bitmap array: positive packed values and negative JSL colors // leave the negative values alone and don't use them for scaling. Use the biggest value of all the // packed value to scale up/down to make the biggest 255 on the 8-bit rgb scale. this might be // brighter than intended. poscols = Loc( bitmap > 0 ); rmax = gmax = bmax = 0; // scale for briteness...find the max which might be as small as 1/32 or as large as 8 // negative values are jsl colors already and their intensity is not adjusted For Each( {i}, poscols, {red, green, blue} = unpackcolor( bitmap[i] ); rmax = Max( red, rmax ); gmax = Max( green, gmax ); bmax = Max( blue, bmax ); ); maxcol = Max( rmax, gmax, bmax ); Show( maxcol ); // all the frames should use the same adjustment if(0.140
          <MAXCOL><.203, maxcol check")); for each( {i}, poscols, {red, green, blue}="unpackcolor(" bitmap[i]="RGB" ); color( red maxcol, green blue addnewframe("p"||char(1e9+nframes*time)); save a numbered .png show( time,as date( today() ) );wait(.01); loop over time saveframes(8000 frames,99); ms. 8000ms the full loop. (hp time() - start) 1e6 < ode></MAXCOL>
         </NSPHERES>
        </SAVEIMAGE>

<DIV class="lia-spoiler-noscript-container"> <DIV class="lia-spoiler-noscript-content">start = HP Time(); xypix = 512; // 32는 프레임당 22초, 256은 프레임당 22분, 128은 프레임당 6분 소요 nframes=128; ambient=.0005; // 0.0001은 거의 보이지 않음 lightPosition = -40. || -40. || 0; // 왼쪽 상단. z=0은 눈 근처, -1은 장면에 더 가까움 lightPower = 50; filesdir="$desktop/donutpics/"; // empty()가 아님! makegif = "$desktop/donut.gif"; // empty() 또는 "$desktop/filename.gif" makewebp = "$desktop/donut.webp"; // empty() 또는 "$desktop/filename.webp" -- jpip.bat 설치 필요 Pillow 설치 //deletedirectory(filesdir);createdirectory(filesdir); if(!Directory Exists(filesdir),throw("디렉토리가 존재하지 않아 중지되었습니다: "||filesdir)); if(nitems(filesindirectory(filesdir))!=0,throw("디렉토리가 비어 있지 않아 중지되었습니다: "||filesdir)); if(!isempty(makewebp), // webp를 생성하는 Python 코드 조각이 필요합니다...없으면 일찍 실패합니다. rc = Python Execute({},{}, "\[from PIL import Image ]\",echo(0)); if(rc!=0, throw("Python 초기화 오류 rc="||char(rc)),"ok"); ); addNewFrame = Function( {filename},{img}, // 전역 비트맵을 .png 형식으로 filesdir에 씁니다. img = New Image( bitmap ); img< <SAVEIMAGE> 51비트 정수 사용 가능. cscale = 2 ^ 17; // 3*17==51비트를 52-53비트 double로 변환합니다. 부호 비트는 다른 곳에서도 사용됩니다. cscaleMax = 2 ^ 3; // 가장 큰 RGB packcolor 핸들 // packcolor는 색상당 17비트 double을 생성하기 위한 병렬 할당 내부에 있습니다. // 색상당 8비트 이상의 해상도는 색상 손실 없이 스케일링을 지연시키는 데 도움이 됩니다. // unpackcolor는 병렬 할당 후에 필요합니다. unpackcolor = Function( {pc}, {r, g, b}, r = Mod( pc, cscale ) / (cscale / cscaleMax - 1); pc = Floor( pc / cscale ); g = Mod( pc, cscale ) / (cscale / cscaleMax - 1); pc = Floor( pc / cscale ); b = Mod( pc, cscale ) / (cscale / cscaleMax - 1); Eval List( {r, g, b} ); ); finalImage=0; // 애니메이션 GIF를 다시 생성하는 플래그입니다. // 단순한 GIF 루프 이상의 용도로 사용하려면 // 이 코드를 재구성할 수 있습니다. 현재는 0에서 1 사이의 "시간" 값을 사용하여 // 카메라가 한 바퀴 완전히 회전하도록 합니다. Shadertoy는 "t"라는 시간을 사용하여 // 각도를 계산합니다. Shadertoy는 일반적으로 GIF 루프를 만드는 것이 아니라 // 마우스로 제어되는 디스플레이를 만듭니다. // 2의 거듭제곱을 사용하는 것은 단계에 필수적인 것은 아니지만 시작과 끝 프레임을 일치시킵니다. // 1.0 미만은 마지막 프레임이 생략됨을 의미합니다. for(time=0.0,time<1.0,time+=1/nframes, // y축 회전(화면상 수직)은 각도에 따라 수행됩니다. 그 다음 // 카메라가 타일 바닥을 내려다보도록 X축을 약간 기울입니다. // 그런 다음 카메라가 0,0,0 근처에 있는 장면이 보이도록 뒤로 이동합니다. // 여기서 '뒤로'는 Z축을 의미합니다. 이 용어 사용은 // 항상 혼란스럽습니다! angle = time*2*pi(); anim_8=8*angle; anim_7=7*angle; anim_3=3*angle; anim_1=1*angle; camera = tranmat(0,0,-8)*getXrot(-.1 *2*pi()+0.06*sin(anim_1))*getYrot(anim_1); // 장면 목록은 목록의 목록입니다... 그리고 효율적인 값을 저장하려면 목록을 평가해야 합니다. scene = Eval List( { // tranmat: Y축은 화면 아래쪽으로 양수, Z축은 카메라 쪽으로 양수 Eval List( {"torus", Expr( ptrep = pt[1]-12*round(pt[1]/12)||pt[2]-12*round(pt[2]/12)||pt[3]; // X축과 Z축을 따라 토러스를 반복합니다(Y축으로 회전) <A href="https://iquilezles.org/articles/sdfrepetition/" target="_blank" rel="nofollow noopener noreferrer">https://iquilezles.org/articles/sdfrepetition/</A> sdTorus( ptrep, [2 1] ); ), Eval List( {"solid", RGB Color( "white" )} ), // Inverse( scalemat( 1, 1, 1 ) * tranmat( 0, 1/*바닥까지*/, 0 ) * rotmat(90,0,0))} ), // Eval List( {"floor", Expr( sdPlane( pt, [0 -1 0], 2.1 ) ), Eval List( {"checker", RGB Color( "green" )} ), // Identity( 4 )} )// } ); nspheres = 11;// 원형으로 튕기는 구체 n개를 추가합니다. Y축 anim8 + p0는 튕김을 단계적으로 조정합니다. for( p=0,p <NSPHERES> maxt,i=1e99/*break*/ ); ); res = max(res,-1.0); 0.25*(1.0+res)*(1.0+res)*(2.0-res); ), // <A href="https://github.com/scratchapixel/scratchapixel-code/blob/main/perspective-and-orthographic-projection-matrix/geometry.h" target="_blank" rel="nofollow noopener noreferrer">https://github.com/scratchapixel/scratchapixel-code/blob/main/perspective-and-orthographic-projection-matrix/geometry.h</A> dotProduct = Function( {a, b}, // v2 또는 v3 x * vx + y * vy + z * vz Sum( a :* b ) // 스칼라: 벡터 a와 b가 같은 방향을 가리키는 정도 ), crossProduct = Function( {a, b}, // v3만 해당 y * vz - z * vy, z * vx - x * vz, x * vy - y * vx a[2] * b[3] - a[3] * b[2] || a[3] * b[1] - a[1] * b[3] || a[1] * b[2] - a[2] * b[1]; // 벡터: a와 b 모두에 수직인 벡터 ), // <A href="https://www.shadertoy.com/view/4dSBz3" target="_blank" rel="nofollow noopener noreferrer">https://www.shadertoy.com/view/4dSBz3</A> 및 <A href="https://iquilezles.org/articles/normalsSDF/" target="_blank" rel="nofollow noopener noreferrer">https://iquilezles.org/articles/normalsSDF/</A> // 거리 필드의 중심 차이를 이용하여 법선을 계산합니다. // 구체의 경우 더 간단한 방법이 있으며, 토러스도 마찬가지일 것입니다. 평면도 마찬가지입니다! // 지금은 코드를 간단하게 유지하고 있습니다. // <A href="https://iquilezles.org/articles/normalsSDF/" target="_blank" rel="nofollow noopener noreferrer">https://iquilezles.org/articles/normalsSDF/</A> - 사면체 기법 calcNormal = Function( {p}, p = p[1] || p[2] || p[3]; normalize( // 이것은 p를 중심으로 하는 사면체입니다. [1 -1 -1] * map( p + [.001 -.001 -.001] ) + // [-1 -1 1] * map( p + [-.001 -.001 .001] ) + // [-1 1 -1] * map( p + [-.001 .001 -.001] ) + // [1. 1 1.] * map( p + [.0010 .001 .0010] ) // ); // ), // mapFound = ., // 행진이 어떤 객체와 만났는지 기억하기 위한 전역 변수입니다. // map 함수는 장면의 모든 객체에 대해 p를 테스트하고 가장 가까운 객체를 반환합니다. map = Function( {p}, {i, result, tresult, pt}, p = p[1] |/ p[2] |/ p[3] |/ 1; result = 1e99; mapFound = .; For( i = 1, i <= N Items( scene ), i += 1, pt = scene[i][sceneDistanceMatrix] * p; // 토러스의 X축 회전은 반복 작업 전에 발생하므로 Z축은 Y축입니다. pt = pt[1] || pt[2] || pt[3]; tresult = Eval( scene[i][sceneDistanceExpr] ); If( tresult < result, result = tresult; mapFound = i; // 기억하세요. 대부분의 호출에서는 필요하지 않습니다. ); ); result; ), // // // 장면 목록입니다. sceneDistanceExpr expr() 함수는 병렬 할당 로컬 변수에 있는 함수만 사용해야 합니다! // // 먼저 장면 목록을 해석하는 방법을 설명하는 몇 가지 인덱스입니다. sceneDistanceName = 1, // sceneDistanceExpr = 2, // sceneDistanceMaterial = 3, // /**/sceneDistanceMaterial_pattern = 1, // /**/sceneDistanceMaterial_color = 2, // sceneDistanceMatrix = 4, // lightPosition=lightPosition, // lightPower=lightPower, // // 끝에 쉼표 없음... scene=scene // }, // 각 스레드에 대한 로컬 변수 // // 마지막으로 배열 요소를 할당하는 JSL 코드입니다. Parallel Assign은 // 이미 요소를 선택하고 스케일링된 인덱스를 제공합니다. 0.68 스케일은 // 보기 좋게 하기 위해 경험적으로 선택되었습니다. 여기서는 할당할 비트맵에 접근할 수 없습니다. // 덮어쓰기될 이전 값에도 접근할 수 없습니다(구현상의 버그/결함... 물론 복사본을 사용할 수 있습니다). // bitmap[yImage( -.68, .68 ), xImage( -.68, .68 )] = (// // 여기서부터 상당히 표준적인 레이 마칭 코드가 시작됩니다. 웹에서 훌륭한 설명을 찾아보는 것이 좋습니다. ro = 0 || 0 || 1 ; // 레이 원점은 0,0입니다. 이 눈은 z=0의 이미지 평면보다 1단위 앞에 있습니다. rd = (xImage || yImage || 0) - ro ; // 레이 방향, 이미지 평면은 eye_origin에서 z 단위만큼 떨어져 있습니다. rd = normalize( rd ) ; // 길이를 1로 정규화 t = 1 ; resultColor = -1 ; // 아무것도 감지되지 않으면 배경색 For( i = 0, i < 1024 & t < 1024, i += 1, // <512는 반복 횟수 제한, <200은 배경에 아무것도 없는 경우의 깊이 제한입니다. p = ro + rd * t; pi = invCamera * (p || 1)`; h = map( pi ); t += h; If( h < .001, object = mapFound; // calcNormal이 map()을 재사용하기 전에 캡처 light = lightPosition; if(0,// 1: 카메라에 부착된 광원 (작업 필요) light = invCamera * (light || 1)`; // 카메라에 대한 상대적인 광원 light = light[[1 2 3]]`; ); // <A href="https://www.shadertoy.com/view/4dSBz3" target="_blank" rel="nofollow noopener noreferrer">https://www.shadertoy.com/view/4dSBz3</A> ... // 광원 방향(light-p)과 normalVec의 내적을 취하여 확산 조명을 계산합니다. lightVec = normalize( light - pi[[1 2 3]]` /*p*/ ); normalVec = calcNormal( pi[[1 2 3]]` ); dif = clamp( dotProduct( normalVec, lightVec ), 0., 1. ); dif *= softShadow(pi,lightVec, .02/*최소 t*/, 30/*최대 t*/, .1/*광선의 폭*/); // <<<< 이 부분을 생략하면 그림자가 생기지 않고 속도가 크게 향상됩니다. // 광 강도를 곱하고 광원까지의 거리의 제곱으로 나눕니다. // 후처리 단계에서 조명을 조정하여 특정 색상의 밝은 픽셀이 하나 이상 나타나도록 합니다. // 과다 노출(광선이 너무 밝음) 또는 밴딩(광선이 너무 어두움)이 발생하면 1e0만큼 위 또는 아래로 조정합니다. dif *= lightPower / dotProduct( light - p, light - p ); // 1e-5 ... 1e5 dif += ambient; // 주변광을 약간 추가합니다. 초기 테스트 사례에서 .0001을 추가하면 그림자가 완전히 검게 되는 것을 방지할 수 있었습니다. // <A href="https://iquilezles.org/articles/checkerfiltering/" target="_blank" rel="nofollow noopener noreferrer">https://iquilezles.org/articles/checkerfiltering/</A> 그의 알고리즘을 사용하지 않고 직접 구현했습니다... If( scene[object][sceneDistanceMaterial][sceneDistanceMaterial_pattern] == "checker", // t는 체커 패턴이 있는 이 객체까지의 거리입니다. // t가 커질수록 패턴이 덜 보이게 됩니다. // 진폭은 x축과 y축 사인파의 곱으로 타일을 형성합니다. *5는 // 타일 크기를 결정합니다(값이 클수록 타일이 작아집니다). ^.4 제곱을 해도 // 타일 사이의 전환 부분에 약간의 기울기가 있습니다. bigdiv는 1과 2 사이의 숫자로 // 전환 기울기를 나타냅니다. smalldiv는 항상 1입니다. divisor는 smalldiv와 bigdiv 사이에서 보간됩니다. t는 거리이며 바닥이 멀리 있을 때는 smalldiv를, 가까이 있을 때는 bigdiv를 선택합니다. smalldiv는 밝은 타일 색상과 어두운 타일 색상 사이의 중간 값을 선택합니다. bigdiv는 어두운 타일을 더 어둡게, 밝은 타일을 더 밝게 만듭니다. 멀리 있는 타일은 평균 색상이고, // 타일 전환 근처의 타일도 평균 색상이며 결과적으로 약간의 앤티앨리어싱 효과가 나타납니다. amplitude = sin(pi[1]*5) * sin(pi[3]*5); // 1,3은 바닥이 놓인 xz 평면입니다. <<< 불행히도 이것이 바닥이라는 것을 알아야 합니다. bigdiv = 1+abs(amplitude)^.4; // 경험적으로 .3이나 .5보다 .4가 더 좋습니다. smalldiv=1; // 경험적: 에일리어싱이 발생하기 전 유용한 z 거리. 적합 모델의 공식. // 32x32 13 // 128x128 26 // 512x512 52 //zdistance = (-42.25) + 9.75 * log(xypix,2) + 1.625 * (log(xypix,2) - 7) * (log(xypix,2) - 7); divisor = interpolate(t, -1e99,bigdiv, 3,bigdiv, zdistance,smalldiv, 1e99,smalldiv); if(amplitude > 0, dif /= divisor; // , // dif *= divisor; // ) ); resultColor = Max( dif, 0 ); resultColor = resultColor ^ 0.4545; // 감마 보정, 출처는 확실하지 않지만 여러 소스에서 .4545를 사용합니다. i = 1e99; /* break */ ); ); If( resultColor < 0, // If( resultColor != -1, Show( resultColor ) ); // 배경, 대부분 RGB Color( .4, .5, .6 );// JSL 색상은 음수입니다. , /*else if */ Is Missing( resultColor ), // RGB Color( .8, .1, .8 )// 오류 색상, 음수 JSL 색상 , // 그렇지 않으면 최대 3비트 정수와 14비트 소수로 구성된 양수 압축 색상 {빨강, 초록, 파랑} = Color To RGB( scene[object][sceneDistanceMaterial][sceneDistanceMaterial_color] ); packcolor( red * resultColor, green * resultColor, blue * resultColor ) // ; ) ; // ); // bitmap= expr );//ParallelAssign // 비트맵 배열에는 양수 압축 값과 음수 JSL 색상이라는 두 종류의 값이 있습니다. // 음수 값은 그대로 두고 스케일링에 사용하지 않습니다. 모든 압축 값 중 가장 큰 값을 사용하여 // 8비트 RGB 스케일에서 가장 큰 255가 되도록 확대/축소합니다. 이로 인해 // 의도한 것보다 더 밝아질 수 있습니다. poscols = Loc( bitmap > 0 ); rmax = gmax = bmax = 0; // 밝기 조절... 최대값을 찾습니다. 최대값은 1/32처럼 작을 수도 있고 8처럼 클 수도 있습니다. // 음수 값은 이미 JSL 색상이며 강도가 조정되지 않습니다. For Each( {i}, poscols, {red, green, blue} = unpackcolor( bitmap[i] ); rmax = Max( red, rmax ); gmax = Max( green, gmax ); bmax = Max( blue, bmax ); ); maxcol = Max( rmax, gmax, bmax ); Show( maxcol ); // 모든 프레임은 동일한 조정을 사용해야 합니다. if(0.140 <MAXCOL><.203, maxcol check")); for each( {i}, poscols, {red, green, blue}="unpackcolor(" bitmap[i]="RGB" ); color( red maxcol, green blue addnewframe("p"||char(1e9+nframes*time)); save a numbered .png show( time,as date( today() ) );wait(.01); loop over time saveframes(8000 frames,99); ms. 8000ms the full loop. (hp time() - start) 1e6 < iv></MAXCOL></NSPHERES></SAVEIMAGE></DIV> </DIV>

GIF - 12MB	WebP - 10MB

기존 GIF 이미지 압축 방식은 파일 크기를 20% 증가시키고 심각한 색상 밴딩 현상을 초래했습니다. WebP는 훨씬 뛰어난 화질을 제공합니다. 토러스는 하나의 SDF(이미지 데이터 프레임)를 사용하며, 매우 낮은 비용으로 반복됩니다. 각기 다른 색상의 구체들은 별도의 SDF를 가지고 있으며, 타일 바닥 또한 별도의 SDF를 사용합니다. 바닥 타일은 깜빡임으로 인한 계단 현상을 방지하기 위해 멀어질수록 자연스럽게 사라집니다. 부드러운 그림자는 두 가지 그림자 효과를 결합한 것입니다. 조명은 모델에 고정되어 있고, 조명과 모델은 카메라 앞에서 회전합니다. 구체들은 바닥에 완전히 닿지 않고 튕겨 오릅니다. 회전하는 동안 카메라 앵글이 바뀌어 하늘이 보이도록 했습니다. 이 GIF는 PIL의 GIF 작성기가 아닌 JMP의 GIF 작성기로 생성되었습니다. GIF를 최적화하는 방법은 여러 가지가 있으며, JMP와 PIL은 이미지에 따라 다른 최적화 방식을 선택합니다.

컴파일된 프로그램이 GPU에서 실행되지 않으면 레이 마칭 코드가 너무 느려서 더 이상 수정할 계획이 없습니다. 정말 필요하다면 그림자를 제외하고, 바닥을 단순화하고, 간단한 기본 도형의 표면 법선을 직접 계산하는 방식(추가적인 레이 마칭 4개를 사용하지 않고)으로 10배 정도 성능을 향상시킬 수 있을 겁니다. 하지만 그래도 초당 프레임 수가 아니라 분당 프레임 수가 소요될 것입니다.

https://www.tylerbovenzi.com/RayMarch/ - 좋은 그림들 https://www.shadertoy.com/view/4dSBz3 - 간단한 예제 https://www.shadertoy.com/view/4dSfRc - 튜토리얼 https://iquilezles.org/articles/rmshadows/ - 소프트 섀도우 https://iquilezles.org/articles/checkerfiltering/ - 체커보드 https://iquilezles.org/articles/sdfrepetition/ - 반복 https://www.opengl-tutorial.org/beginners-tutorials/tutorial-3-matrices/ - 행렬 회전 등 https://iquilezles.org/articles/distfunctions/ - 거리 함수 목록 https://www.shadertoy.com/view/Xds3zN - 거리 함수 표시 https://www.shadertoy.com/view/WtGfRV - SIGGRAPH RayMarching 튜토리얼

Comments

Quick Links