codeimage.io

STUDIO HAZE · image

Topaz source

Open by house policy. Topaz is our own language.

Topaz 5.21 · 113 files

topaz/src/image_raster.tpz

Topaz · 24321 B · Original file

1// Page headers, raster pixels computed as functions of their coordinates, and
2// canonical PNG output.
4import std.bytes { Bytes }
5import hash { 해시이백오십육 }
6import plan {
7 띠팔레트,
8 범위씻김팔레트,
9 범위코드,
10 이미지계획,
11 이미지배치,
12 이미지쪽계획,
13 이미지팔레트,
14 이역할팔레트,
15 파일프로그램코드,
16 팔그물팔레트,
17 픽셀글꼴,
18 형식팔레트,
20import render { 글자그림, 사각안, 이미지머리, 이역할변형, 청크만들기 }
21import structure { 구조노드, 구조입력, 이미지요청 }
22import util { 거듭제곱이, 십육진숫자, 작은값, 큰값 }
24export record 그림준비 {
25 요청: 이미지요청,
26 머리: 이미지머리,
27 머리바이트: ByteBuffer,
28 보호바이트: ByteBuffer,
29 노드시작: int,
30 노드끝: int,
31 수직씻김: Array<int>,
32 수평씻김: Array<int>,
33 이역할: Array<int>,
34 팔그물: Array<int>
36export record 주사그림 { 준비: 그림준비, 바이트들: ByteBuffer }
38export function 조상또는자신(노드들: Array<구조노드>, 순번: int, 조상: int) -> bool {
39 let mut 현재 = 순번
40 while 현재 >= 0 {
41 if 현재 == 조상 { return true }
42 현재 = 노드들[현재].부모순번
43 }
44 false
47function 범위깊이(노드들: Array<구조노드>, 언어번호: int, 순번: int) -> int {
48 let mut 깊이 = 0
49 let mut 현재 = 순번
50 while 현재 >= 0 {
51 let 노드 = 노드들[현재]
52 if 범위코드(언어번호, 노드.코드워드) && !파일프로그램코드(언어번호, 노드.코드워드) { 깊이 = 깊이 + 1 }
53 현재 = 노드.부모순번
54 }
55 깊이
58function 머리만들기(요청: 이미지요청, 계획: 이미지계획, 쪽: 이미지쪽계획) -> Result<ByteBuffer, string> {
59 let mut 본문 = ByteBuffer.allocate(192)
60 본문.set(0, 67); 본문.set(1, 73); 본문.set(2, 70); 본문.set(3, 54)
61 본문.set(4, 2); 본문.set(5, 1); 본문.set(6, 요청.언어번호); 본문.set(7, 요청.팔레트번호)
62 본문.set(8, 8); 본문.set(9, 3); 본문.set(10, 2); 본문.set(11, 0)
63 본문.set(12, 1304 / 256); 본문.set(13, 1304 % 256)
64 본문.set(14, 쪽.배치.높이 / 256); 본문.set(15, 쪽.배치.높이 % 256)
65 본문.set(16, 0); 본문.set(17, 71)
66 본문.set(18, 쪽.배치.판행수 / 256); 본문.set(19, 쪽.배치.판행수 % 256)
67 본문.set(20, 12); 본문.set(21, 30); 본문.set(22, 6); 본문.set(23, 2)
68 본문.set(24, 쪽.배치.띠위 / 256); 본문.set(25, 쪽.배치.띠위 % 256)
69 본문.set(26, 쪽.배치.띠행수 / 256); 본문.set(27, 쪽.배치.띠행수 % 256)
70 let 수치들 = [쪽.노드끝 - 쪽.노드시작, 쪽.보호길이, 쪽.논리끝 - 쪽.논리시작, 쪽.패리티길이]
71 let mut 색인 = 0
72 while 색인 < 4 {
73 let 값 = 수치들[색인]
74 let 위치 = 28 + 색인 * 4
75 본문.set(위치, (값 / 16777216) % 256); 본문.set(위치 + 1, (값 / 65536) % 256)
76 본문.set(위치 + 2, (값 / 256) % 256); 본문.set(위치 + 3, 값 % 256)
77 색인 = 색인 + 1
78 }
79 let 프로필 = ByteBuffer.fromBytes(Bytes.fromHex(요청.프로필해시)?)
80 let 키 = ByteBuffer.fromBytes(Bytes.fromHex(요청.키해시)?)
81 let 구조 = ByteBuffer.fromBytes(Bytes.fromHex(요청.구조해시)?)
82 let 세트 = ByteBuffer.fromBytes(Bytes.fromHex(계획.세트해시)?)
83 본문.copy(프로필, 0, 44, 32); 본문.copy(키, 0, 76, 32); 본문.copy(구조, 0, 108, 16); 본문.copy(세트, 0, 128, 32)
84 본문.set(124, 쪽.쪽번호); 본문.set(125, 계획.쪽들.length - 1); 본문.set(126, 요청.크롬번호)
85 let 제목바이트 = ByteBuffer.fromBytes(요청.제목.encodeUtf8())
86 본문.set(127, 제목바이트.length())
87 본문.copy(제목바이트, 0, 160, 제목바이트.length())
88 let 원본줄수 = 요청.원본줄수
89 본문.set(184, (원본줄수 / 16777216) % 256); 본문.set(185, (원본줄수 / 65536) % 256)
90 본문.set(186, (원본줄수 / 256) % 256); 본문.set(187, 원본줄수 % 256)
91 let 노드시작 = 쪽.노드시작
92 본문.set(188, (노드시작 / 16777216) % 256); 본문.set(189, (노드시작 / 65536) % 256)
93 본문.set(190, (노드시작 / 256) % 256); 본문.set(191, 노드시작 % 256)
94 let 검사합 = ByteBuffer.fromBytes(해시이백오십육(본문.toBytes())?)
95 let mut 전체 = ByteBuffer.allocate(224)
96 전체.copy(본문, 0, 0, 192); 전체.copy(검사합, 0, 192, 32)
97 Ok(전체)
100function 머리레코드(요청: 이미지요청, 계획: 이미지계획, 쪽: 이미지쪽계획) -> 이미지머리 {
101 이미지머리 {
102 버전: 2, 언어번호: 요청.언어번호, 팔레트번호: 요청.팔레트번호,
103 너비: 1304, 높이: 쪽.배치.높이, 판행수: 쪽.배치.판행수,
104 띠위: 쪽.배치.띠위, 띠행수: 쪽.배치.띠행수,
105 노드수: 쪽.노드끝 - 쪽.노드시작, 보호길이: 쪽.보호길이,
106 논리길이: 쪽.논리끝 - 쪽.논리시작, 패리티길이: 쪽.패리티길이,
107 프로필해시: 요청.프로필해시, 키해시: 요청.키해시,
108 구조해시앞: 요청.구조해시.scalars().slice(0, 32).join(""),
109 쪽번호: 쪽.쪽번호, 쪽수: 계획.쪽들.length, 노드시작: 쪽.노드시작,
110 크롬번호: 요청.크롬번호, 제목: 요청.제목, 원본줄수: 요청.원본줄수,
111 세트해시: 계획.세트해시
112 }
115export function 그림준비하기(요청: 이미지요청, 계획: 이미지계획, 쪽: 이미지쪽계획, 보호: Bytes) -> Result<그림준비, string> {
116 let 머리바이트 = 머리만들기(요청, 계획, 쪽)?
117 let 보호바이트 = ByteBuffer.fromBytes(보호)
118 if 보호바이트.length() != 쪽.보호길이 { return Err("보호 조각 길이가 계획과 다릅니다") }
119 let 노드수 = 쪽.노드끝 - 쪽.노드시작
120 let mut 수직씻김: Array<int> = []
121 let mut 수평씻김: Array<int> = []
122 let mut 이역할: Array<int> = []
123 let mut 팔그물: Array<int> = []
124 let mut 색인 = 0
125 while 색인 < 노드수 { 수직씻김.push(0); 수평씻김.push(0); 이역할.push(-1); 팔그물.push(-1); 색인 = 색인 + 1 }
126 let 노드들 = 요청.구조.노드들
127 let mut 범위순번 = 0
128 while 범위순번 < 노드들.length {
129 let 범위 = 노드들[범위순번]
130 if 범위코드(요청.언어번호, 범위.코드워드) && !파일프로그램코드(요청.언어번호, 범위.코드워드) {
131 let mut 끝 = 범위순번
132 let mut 살피기 = 범위순번 + 1
133 while 살피기 < 노드들.length && 조상또는자신(노드들, 살피기, 범위순번) { 끝 = 살피기; 살피기 = 살피기 + 1 }
134 let 깊이 = 범위깊이(노드들, 요청.언어번호, 범위순번)
135 let 보이는시작 = 큰값(범위순번, 쪽.노드시작)
136 let 보이는끝 = 작은값(끝, 쪽.노드끝 - 1)
137 let mut 순번 = 보이는시작
138 while 순번 < 보이는끝 {
139 let 지역 = 순번 - 쪽.노드시작
140 if 지역 % 12 != 11 && 수직씻김[지역] < 깊이 { 수직씻김[지역] = 깊이 }
141 순번 = 순번 + 1
142 }
143 순번 = 보이는시작
144 while 순번 + 12 <= 보이는끝 {
145 let 지역 = 순번 - 쪽.노드시작
146 if 수평씻김[지역] < 깊이 { 수평씻김[지역] = 깊이 }
147 순번 = 순번 + 1
148 }
149 }
150 범위순번 = 범위순번 + 1
151 }
152 색인 = 0
153 while 색인 < 노드수 {
154 let 노드 = 노드들[쪽.노드시작 + 색인]
155 if 노드.부모순번 >= 0 { 이역할[색인] = 이역할변형(노드.자식필드) }
156 if 노드.식별자있음 && 노드.식별자류번호 < 9 { 팔그물[색인] = 노드.식별자류번호 }
157 색인 = 색인 + 1
158 }
159 Ok(그림준비 {
160 요청: 요청, 머리: 머리레코드(요청, 계획, 쪽), 머리바이트: 머리바이트,
161 보호바이트: 보호바이트, 노드시작: 쪽.노드시작, 노드끝: 쪽.노드끝,
162 수직씻김: 수직씻김, 수평씻김: 수평씻김, 이역할: 이역할, 팔그물: 팔그물
163 })
166function 크롬색(준비: 그림준비, 가로: int, 세로: int, 바탕: int) -> int {
167 if 준비.머리.크롬번호 != 1 { return 바탕 }
168 let mut 색 = 바탕
169 let 잉크 = 2959909
170 let 줄색 = 5458753
171 let 제목글자수 = 준비.머리.제목.scalars().length
172 if 제목글자수 > 0 && 글자그림(준비.머리.제목, (1304 - 제목글자수 * 12) / 2, 2, 3, 가로, 세로) { 색 = 잉크 }
173 if 사각안(가로, 세로, 56, 19, 1192, 1) || 사각안(가로, 세로, 56, 21, 1192, 1) { 색 = 줄색 }
174 let 기림글 = "LINES {준비.머리.원본줄수} / NODES {준비.요청.구조.노드들.length}"
175 if 글자그림(기림글, (1304 - 기림글.scalars().length * 8) / 2, 42, 2, 가로, 세로) { 색 = 잉크 }
176 if 사각안(가로, 세로, 56, 58, 1192, 1) || 사각안(가로, 세로, 56, 60, 1192, 1) { 색 = 줄색 }
177 let 꼬리위 = 준비.머리.높이 - 64
178 if 사각안(가로, 세로, 56, 꼬리위 + 11, 1192, 1) || 사각안(가로, 세로, 56, 꼬리위 + 13, 1192, 1) { 색 = 줄색 }
179 let 쪽글 = "{준비.머리.쪽번호 + 1} / {준비.머리.쪽수}"
180 if 글자그림(쪽글, (1304 - 쪽글.scalars().length * 12) / 2, 준비.머리.높이 - 35, 3, 가로, 세로) { 색 = 잉크 }
181 let 등왼쪽 = if 준비.머리.쪽번호 % 2 == 0 { 0 } else { 1300 }
182 if 사각안(가로, 세로, 등왼쪽, 64, 4, 준비.머리.높이 - 64) { 색 = 7365459 }
183 for 장식가로 in [18, 1277] {
184 if 사각안(가로, 세로, 장식가로, 7, 9, 1) || 사각안(가로, 세로, 장식가로, 7, 1, 6) ||
185 사각안(가로, 세로, 장식가로, 65, 9, 1) || 사각안(가로, 세로, 장식가로, 65, 1, 6) ||
186 사각안(가로, 세로, 장식가로, 준비.머리.높이 - 18, 9, 1) ||
187 사각안(가로, 세로, 장식가로, 준비.머리.높이 - 23, 1, 6) { 색 = 8417112 }
188 }
189 let 인장왼쪽 = 1247
190 let 인장위 = 준비.머리.높이 - 49
191 if 사각안(가로, 세로, 인장왼쪽, 인장위, 36, 1) || 사각안(가로, 세로, 인장왼쪽, 인장위 + 35, 36, 1) ||
192 사각안(가로, 세로, 인장왼쪽, 인장위, 1, 36) || 사각안(가로, 세로, 인장왼쪽 + 35, 인장위, 1, 36) { 색 = 12466730 }
193 let 상대가로 = 가로 - (인장왼쪽 + 5)
194 let 상대세로 = 세로 - (인장위 + 5)
195 if 상대가로 >= 0 && 상대세로 >= 0 && 상대가로 < 26 && 상대세로 < 26 && 상대가로 % 7 < 5 && 상대세로 % 7 < 5 {
196 let 비트 = (상대세로 / 7) * 4 + (상대가로 / 7)
197 if 비트 < 16 {
198 let 해시글자 = 준비.머리.세트해시.scalars()
199 let 바이트 = 십육진숫자(해시글자[(비트 / 8) * 2]) * 16 + 십육진숫자(해시글자[(비트 / 8) * 2 + 1])
200 if (바이트 / 거듭제곱이(7 - (비트 % 8))) % 2 == 1 { 색 = 12466730 }
201 }
202 }
203 색
206function 그림색(준비: 그림준비, 가로: int, 세로: int) -> int {
207 let mut 색 = 15262682
208 let 형식색 = 형식팔레트()
209 if 가로 >= 78 && 세로 >= 24 {
210 let 칸가로 = (가로 - 78) / 2
211 let 칸세로 = (세로 - 24) / 2
212 if (가로 - 78) % 2 < 2 && (세로 - 24) % 2 < 2 && 칸가로 < 320 {
213 let 바이트색인 = 칸세로 * 80 + 칸가로 / 4
214 if 바이트색인 < 준비.머리바이트.length() {
215 let 부분 = 칸가로 % 4
216 let 숫자 = (준비.머리바이트.get(바이트색인) / 거듭제곱이((3 - 부분) * 2)) % 4
217 색 = 형식색[숫자]
218 }
219 }
220 }
221 let 코드색 = 이미지팔레트(준비.머리.언어번호)
222 let mut 색인 = 0
223 while 색인 < 코드색.length {
224 if 사각안(가로, 세로, 804 + 색인 * 16, 24, 12, 12) { 색 = 코드색[색인] }
225 색인 = 색인 + 1
226 }
227 let 표들 = [이역할팔레트(), 팔그물팔레트(), 범위씻김팔레트()]
228 let 왼쪽들 = [804, 884, 964]
229 let mut 표번호 = 0
230 while 표번호 < 3 {
231 색인 = 0
232 while 색인 < 표들[표번호].length {
233 if 사각안(가로, 세로, 왼쪽들[표번호] + 색인 * 8, 42, 6, 6) { 색 = 표들[표번호][색인] }
234 색인 = 색인 + 1
235 }
236 표번호 = 표번호 + 1
237 }
238 let 노드수 = 준비.노드끝 - 준비.노드시작
239 let 판상대세로 = 세로 - 71
240 if 판상대세로 >= 0 {
241 let 행 = 판상대세로 / 36
242 let 행안 = 판상대세로 % 36
243 if 행안 < 30 {
244 let 수직상대 = 가로 - 109
245 if 수직상대 >= 0 && 수직상대 % 108 < 6 {
246 let 열 = 수직상대 / 108
247 let 지역 = 행 * 12 + 열
248 if 열 < 12 && 지역 < 노드수 && 준비.수직씻김[지역] > 0 {
249 색 = 범위씻김팔레트()[작은값(준비.수직씻김[지역], 3) - 1]
250 }
251 }
252 } else {
253 let 열상대 = 가로 - 7
254 if 열상대 >= 0 {
255 let 열 = 열상대 / 108
256 let 열안 = 열상대 % 108
257 let 지역 = 행 * 12 + 열
258 if 열 < 12 && 열안 < 102 && 지역 < 노드수 && 준비.수평씻김[지역] > 0 {
259 색 = 범위씻김팔레트()[작은값(준비.수평씻김[지역], 3) - 1]
260 }
261 }
262 }
263 }
264 let 첫열가로 = 가로 - 55
265 let 첫열세로 = 세로 - 65
266 if 첫열가로 >= 0 && 첫열가로 < 6 && 첫열세로 >= 0 && 첫열세로 % 36 < 6 {
267 let 지역 = (첫열세로 / 36) * 12
268 if 지역 < 노드수 && 준비.이역할[지역] >= 0 { 색 = 이역할팔레트()[준비.이역할[지역]] }
269 }
270 let 역할가로 = 가로 - 1
271 let 역할세로 = 세로 - 83
272 if 역할가로 >= 0 && 역할세로 >= 0 && 역할가로 % 108 < 6 && 역할세로 % 36 < 6 {
273 let 열 = 역할가로 / 108
274 let 행 = 역할세로 / 36
275 let 지역 = 행 * 12 + 열
276 if 열 >= 1 && 열 < 12 && 지역 < 노드수 && 준비.이역할[지역] >= 0 { 색 = 이역할팔레트()[준비.이역할[지역]] }
277 }
278 let 그물가로 = 가로 - 109
279 let 그물세로 = 세로 - 71
280 if 그물가로 >= 0 && 그물세로 >= 0 && 그물가로 % 108 < 6 && 그물세로 % 36 < 6 {
281 let 열 = 그물가로 / 108
282 let 행 = 그물세로 / 36
283 let 지역 = 행 * 12 + 열
284 if 열 < 12 && 지역 < 노드수 && 준비.팔그물[지역] >= 0 { 색 = 팔그물팔레트()[준비.팔그물[지역]] }
285 }
286 if 판상대세로 >= 0 && 판상대세로 % 36 < 30 {
287 let 열상대 = 가로 - 7
288 if 열상대 >= 0 {
289 let 열 = 열상대 / 108
290 let 열안 = 열상대 % 108
291 let 지역 = (판상대세로 / 36) * 12 + 열
292 if 열 < 12 && 지역 < 노드수 {
293 let 코드칸 = if 열안 < 30 { 0 } else if 열안 >= 36 && 열안 < 66 { 1 } else if 열안 >= 72 && 열안 < 102 { 2 } else { -1 }
294 if 코드칸 >= 0 {
295 let 코드 = 준비.요청.구조.노드들[준비.노드시작 + 지역].코드워드
296 let 숫자 = if 코드칸 == 0 { 코드 / 64 } else if 코드칸 == 1 { (코드 / 8) % 8 } else { 코드 % 8 }
297 색 = 코드색[숫자]
298 }
299 }
300 }
301 }
302 if 가로 >= 4 && 세로 >= 준비.머리.띠위 {
303 let 칸가로 = (가로 - 4) / 2
304 let 칸세로 = (세로 - 준비.머리.띠위) / 2
305 if 칸가로 < 648 {
306 let 바이트색인 = 칸세로 * 162 + 칸가로 / 4
307 if 바이트색인 < 준비.보호바이트.length() {
308 let 부분 = 칸가로 % 4
309 let 숫자 = (준비.보호바이트.get(바이트색인) / 거듭제곱이((3 - 부분) * 2)) % 4
310 색 = 띠팔레트()[숫자]
311 }
312 }
313 }
314 크롬색(준비, 가로, 세로, 색)
317function 사각채우기(그림: 주사그림, 왼쪽: int, 위: int, 너비: int, 높이: int, 색: int) -> bool {
318 let mut 바이트들 = 그림.바이트들
319 let 빨강 = (색 / 65536) % 256
320 let 초록 = (색 / 256) % 256
321 let 파랑 = 색 % 256
322 let mut 세로 = 위
323 while 세로 < 위 + 높이 {
324 let mut 위치 = 세로 * 3913 + 1 + 왼쪽 * 3
325 let 끝 = 위치 + 너비 * 3
326 while 위치 < 끝 {
327 바이트들.set(위치, 빨강); 바이트들.set(위치 + 1, 초록); 바이트들.set(위치 + 2, 파랑)
328 위치 = 위치 + 3
329 }
330 세로 = 세로 + 1
331 }
332 true
335function 바이트그리기(그림: 주사그림, 바이트들: ByteBuffer, 왼쪽: int, 위: int, 행바이트: int, 칸크기: int, 팔레트: Array<int>) -> bool {
336 let mut 색인 = 0
337 while 색인 < 바이트들.length() {
338 let 행 = 색인 / 행바이트
339 let 바이트열 = 색인 % 행바이트
340 let 값 = 바이트들.get(색인)
341 let mut 부분 = 0
342 while 부분 < 4 {
343 let 숫자 = (값 / 거듭제곱이((3 - 부분) * 2)) % 4
344 사각채우기(그림, 왼쪽 + (바이트열 * 4 + 부분) * 칸크기, 위 + 행 * 칸크기, 칸크기, 칸크기, 팔레트[숫자])
345 부분 = 부분 + 1
346 }
347 색인 = 색인 + 1
348 }
349 true
352function 글자그리기(그림: 주사그림, 글: string, 왼쪽: int, 위: int, 배율: int, 색: int) -> bool {
353 let 글자들 = 글.scalars()
354 let mut 글자색인 = 0
355 while 글자색인 < 글자들.length {
356 let 모양 = 픽셀글꼴(글자들[글자색인]).scalars()
357 let mut 행 = 0
358 while 행 < 5 {
359 let mut 열 = 0
360 while 열 < 3 {
361 if 모양[행 * 3 + 열] == "1" {
362 사각채우기(그림, 왼쪽 + 글자색인 * 4 * 배율 + 열 * 배율, 위 + 행 * 배율, 배율, 배율, 색)
363 }
364 열 = 열 + 1
365 }
366 행 = 행 + 1
367 }
368 글자색인 = 글자색인 + 1
369 }
370 true
373function 책크롬그리기(그림: 주사그림) -> bool {
374 let 머리 = 그림.준비.머리
375 let 잉크 = 2959909
376 let 줄색 = 5458753
377 let 제목길이 = 머리.제목.scalars().length
378 if 제목길이 > 0 { 글자그리기(그림, 머리.제목, (1304 - 제목길이 * 12) / 2, 2, 3, 잉크) }
379 사각채우기(그림, 56, 19, 1192, 1, 줄색); 사각채우기(그림, 56, 21, 1192, 1, 줄색)
380 let 기림글 = "LINES {머리.원본줄수} / NODES {그림.준비.요청.구조.노드들.length}"
381 글자그리기(그림, 기림글, (1304 - 기림글.scalars().length * 8) / 2, 42, 2, 잉크)
382 사각채우기(그림, 56, 58, 1192, 1, 줄색); 사각채우기(그림, 56, 60, 1192, 1, 줄색)
383 let 꼬리위 = 머리.높이 - 64
384 사각채우기(그림, 56, 꼬리위 + 11, 1192, 1, 줄색); 사각채우기(그림, 56, 꼬리위 + 13, 1192, 1, 줄색)
385 let 쪽글 = "{머리.쪽번호 + 1} / {머리.쪽수}"
386 글자그리기(그림, 쪽글, (1304 - 쪽글.scalars().length * 12) / 2, 머리.높이 - 35, 3, 잉크)
387 let 등왼쪽 = if 머리.쪽번호 % 2 == 0 { 0 } else { 1300 }
388 사각채우기(그림, 등왼쪽, 64, 4, 머리.높이 - 64, 7365459)
389 for 장식가로 in [18, 1277] {
390 사각채우기(그림, 장식가로, 7, 9, 1, 8417112); 사각채우기(그림, 장식가로, 7, 1, 6, 8417112)
391 사각채우기(그림, 장식가로, 65, 9, 1, 8417112); 사각채우기(그림, 장식가로, 65, 1, 6, 8417112)
392 사각채우기(그림, 장식가로, 머리.높이 - 18, 9, 1, 8417112)
393 사각채우기(그림, 장식가로, 머리.높이 - 23, 1, 6, 8417112)
394 }
395 let 인장왼쪽 = 1247
396 let 인장위 = 머리.높이 - 49
397 let 인장색 = 12466730
398 사각채우기(그림, 인장왼쪽, 인장위, 36, 1, 인장색); 사각채우기(그림, 인장왼쪽, 인장위 + 35, 36, 1, 인장색)
399 사각채우기(그림, 인장왼쪽, 인장위, 1, 36, 인장색); 사각채우기(그림, 인장왼쪽 + 35, 인장위, 1, 36, 인장색)
400 let 해시글자 = 머리.세트해시.scalars()
401 let mut 비트 = 0
402 while 비트 < 16 {
403 let 바이트 = 십육진숫자(해시글자[(비트 / 8) * 2]) * 16 + 십육진숫자(해시글자[(비트 / 8) * 2 + 1])
404 if (바이트 / 거듭제곱이(7 - (비트 % 8))) % 2 == 1 {
405 사각채우기(그림, 인장왼쪽 + 5 + (비트 % 4) * 7, 인장위 + 5 + (비트 / 4) * 7, 5, 5, 인장색)
406 }
407 비트 = 비트 + 1
408 }
409 true
412function 주사그림만들기(준비: 그림준비) -> 주사그림 {
413 let mut 바이트들 = ByteBuffer.allocate(3913 * 준비.머리.높이)
414 let mut 가로 = 0
415 while 가로 < 1304 {
416 let 위치 = 1 + 가로 * 3
417 바이트들.set(위치, 232); 바이트들.set(위치 + 1, 227); 바이트들.set(위치 + 2, 218)
418 가로 = 가로 + 1
419 }
420 let mut 세로 = 1
421 while 세로 < 준비.머리.높이 { 바이트들.copy(바이트들, 0, 세로 * 3913, 3913); 세로 = 세로 + 1 }
422 let 그림 = 주사그림 { 준비: 준비, 바이트들: 바이트들 }
423 바이트그리기(그림, 준비.머리바이트, 78, 24, 80, 2, 형식팔레트())
424 let 코드색 = 이미지팔레트(준비.머리.언어번호)
425 let mut 색인 = 0
426 while 색인 < 코드색.length { 사각채우기(그림, 804 + 색인 * 16, 24, 12, 12, 코드색[색인]); 색인 = 색인 + 1 }
427 let 표들 = [이역할팔레트(), 팔그물팔레트(), 범위씻김팔레트()]
428 let 왼쪽들 = [804, 884, 964]
429 let mut 표번호 = 0
430 while 표번호 < 3 {
431 색인 = 0
432 while 색인 < 표들[표번호].length {
433 사각채우기(그림, 왼쪽들[표번호] + 색인 * 8, 42, 6, 6, 표들[표번호][색인])
434 색인 = 색인 + 1
435 }
436 표번호 = 표번호 + 1
437 }
438 let 노드수 = 준비.노드끝 - 준비.노드시작
439 색인 = 0
440 while 색인 < 노드수 {
441 let 행 = 색인 / 12
442 let 열 = 색인 % 12
443 let 왼쪽 = 7 + 열 * 108
444 let 위 = 71 + 행 * 36
445 if 준비.수직씻김[색인] > 0 {
446 사각채우기(그림, 왼쪽 + 102, 위, 6, 30, 범위씻김팔레트()[작은값(준비.수직씻김[색인], 3) - 1])
447 }
448 if 준비.수평씻김[색인] > 0 {
449 사각채우기(그림, 왼쪽, 위 + 30, 102, 6, 범위씻김팔레트()[작은값(준비.수평씻김[색인], 3) - 1])
450 }
451 if 준비.이역할[색인] >= 0 {
452 let 역할왼쪽 = if 열 == 0 { 왼쪽 + 48 } else { 왼쪽 - 6 }
453 let 역할위 = if 열 == 0 { 위 - 6 } else { 위 + 12 }
454 사각채우기(그림, 역할왼쪽, 역할위, 6, 6, 이역할팔레트()[준비.이역할[색인]])
455 }
456 if 준비.팔그물[색인] >= 0 {
457 사각채우기(그림, 왼쪽 + 102, 위, 6, 6, 팔그물팔레트()[준비.팔그물[색인]])
458 }
459 let 코드 = 준비.요청.구조.노드들[준비.노드시작 + 색인].코드워드
460 let 숫자들 = [코드 / 64, (코드 / 8) % 8, 코드 % 8]
461 let 칸왼쪽들 = [0, 36, 72]
462 let mut 칸 = 0
463 while 칸 < 3 {
464 사각채우기(그림, 왼쪽 + 칸왼쪽들[칸], 위, 30, 30, 코드색[숫자들[칸]])
465 칸 = 칸 + 1
466 }
467 색인 = 색인 + 1
468 }
469 바이트그리기(그림, 준비.보호바이트, 4, 준비.머리.띠위, 162, 2, 띠팔레트())
470 if 준비.머리.크롬번호 == 1 { 책크롬그리기(그림) }
471 그림
474function 고정디플레이트(그림: 주사그림) -> Result<Bytes, string> {
475 그림.바이트들.toBytes().deflateFixedCompress()
478export function 정규피엔지(준비: 그림준비) -> Result<Bytes, string> {
479 let 그림 = 주사그림만들기(준비)
480 let 압축 = ByteBuffer.fromBytes(그림.바이트들.toBytes().zlibFixedCompress()?)
481 let mut 헤더 = ByteBuffer.allocate(13)
482 헤더.set(0, 1304 / 16777216); 헤더.set(1, (1304 / 65536) % 256)
483 헤더.set(2, (1304 / 256) % 256); 헤더.set(3, 1304 % 256)
484 let 높이 = 준비.머리.높이
485 헤더.set(4, (높이 / 16777216) % 256); 헤더.set(5, (높이 / 65536) % 256)
486 헤더.set(6, (높이 / 256) % 256); 헤더.set(7, 높이 % 256)
487 헤더.set(8, 8); 헤더.set(9, 2); 헤더.set(10, 0); 헤더.set(11, 0); 헤더.set(12, 0)
488 let 아이헤더 = ByteBuffer.fromBytes(청크만들기("IHDR".encodeUtf8(), 헤더.toBytes()))
489 let 아이데이터 = ByteBuffer.fromBytes(청크만들기("IDAT".encodeUtf8(), 압축.toBytes()))
490 let 아이끝 = ByteBuffer.fromBytes(청크만들기("IEND".encodeUtf8(), Bytes.fromHex("")?))
491 let 서명 = ByteBuffer.fromBytes(Bytes.fromHex("89504e470d0a1a0a")?)
492 let mut 결과 = ByteBuffer.allocate(서명.length() + 아이헤더.length() + 아이데이터.length() + 아이끝.length())
493 let mut 위치 = 0
494 결과.copy(서명, 0, 위치, 서명.length()); 위치 = 위치 + 서명.length()
495 결과.copy(아이헤더, 0, 위치, 아이헤더.length()); 위치 = 위치 + 아이헤더.length()
496 결과.copy(아이데이터, 0, 위치, 아이데이터.length()); 위치 = 위치 + 아이데이터.length()
497 결과.copy(아이끝, 0, 위치, 아이끝.length())
498 Ok(결과.toBytes())

SHA256 8ec630bcdac3dffd9d5b8eec79bd5b902670e45a4663280eff2626813c674e0e