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, and2
// canonical PNG output.4
import std.bytes { Bytes }5
import hash { 해시이백오십육 }6
import plan {7
띠팔레트,8
범위씻김팔레트,9
범위코드,10
이미지계획,11
이미지배치,12
이미지쪽계획,13
이미지팔레트,14
이역할팔레트,15
파일프로그램코드,16
팔그물팔레트,17
픽셀글꼴,18
형식팔레트,19
}20
import render { 글자그림, 사각안, 이미지머리, 이역할변형, 청크만들기 }21
import structure { 구조노드, 구조입력, 이미지요청 }22
import util { 거듭제곱이, 십육진숫자, 작은값, 큰값 }24
export record 그림준비 {25
요청: 이미지요청,26
머리: 이미지머리,27
머리바이트: ByteBuffer,28
보호바이트: ByteBuffer,29
노드시작: int,30
노드끝: int,31
수직씻김: Array<int>,32
수평씻김: Array<int>,33
이역할: Array<int>,34
팔그물: Array<int>35
}36
export record 주사그림 { 준비: 그림준비, 바이트들: ByteBuffer }38
export function 조상또는자신(노드들: Array<구조노드>, 순번: int, 조상: int) -> bool {39
let mut 현재 = 순번40
while 현재 >= 0 {41
if 현재 == 조상 { return true }42
현재 = 노드들[현재].부모순번43
}44
false45
}47
function 범위깊이(노드들: Array<구조노드>, 언어번호: int, 순번: int) -> int {48
let mut 깊이 = 049
let mut 현재 = 순번50
while 현재 >= 0 {51
let 노드 = 노드들[현재]52
if 범위코드(언어번호, 노드.코드워드) && !파일프로그램코드(언어번호, 노드.코드워드) { 깊이 = 깊이 + 1 }53
현재 = 노드.부모순번54
}55
깊이56
}58
function 머리만들기(요청: 이미지요청, 계획: 이미지계획, 쪽: 이미지쪽계획) -> 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 색인 = 072
while 색인 < 4 {73
let 값 = 수치들[색인]74
let 위치 = 28 + 색인 * 475
본문.set(위치, (값 / 16777216) % 256); 본문.set(위치 + 1, (값 / 65536) % 256)76
본문.set(위치 + 2, (값 / 256) % 256); 본문.set(위치 + 3, 값 % 256)77
색인 = 색인 + 178
}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(전체)98
}100
function 머리레코드(요청: 이미지요청, 계획: 이미지계획, 쪽: 이미지쪽계획) -> 이미지머리 {101
이미지머리 {102
버전: 2, 언어번호: 요청.언어번호, 팔레트번호: 요청.팔레트번호,103
너비: 1304, 높이: 쪽.배치.높이, 판행수: 쪽.배치.판행수,104
띠위: 쪽.배치.띠위, 띠행수: 쪽.배치.띠행수,105
노드수: 쪽.노드끝 - 쪽.노드시작, 보호길이: 쪽.보호길이,106
논리길이: 쪽.논리끝 - 쪽.논리시작, 패리티길이: 쪽.패리티길이,107
프로필해시: 요청.프로필해시, 키해시: 요청.키해시,108
구조해시앞: 요청.구조해시.scalars().slice(0, 32).join(""),109
쪽번호: 쪽.쪽번호, 쪽수: 계획.쪽들.length, 노드시작: 쪽.노드시작,110
크롬번호: 요청.크롬번호, 제목: 요청.제목, 원본줄수: 요청.원본줄수,111
세트해시: 계획.세트해시112
}113
}115
export 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 색인 = 0125
while 색인 < 노드수 { 수직씻김.push(0); 수평씻김.push(0); 이역할.push(-1); 팔그물.push(-1); 색인 = 색인 + 1 }126
let 노드들 = 요청.구조.노드들127
let mut 범위순번 = 0128
while 범위순번 < 노드들.length {129
let 범위 = 노드들[범위순번]130
if 범위코드(요청.언어번호, 범위.코드워드) && !파일프로그램코드(요청.언어번호, 범위.코드워드) {131
let mut 끝 = 범위순번132
let mut 살피기 = 범위순번 + 1133
while 살피기 < 노드들.length && 조상또는자신(노드들, 살피기, 범위순번) { 끝 = 살피기; 살피기 = 살피기 + 1 }134
let 깊이 = 범위깊이(노드들, 요청.언어번호, 범위순번)135
let 보이는시작 = 큰값(범위순번, 쪽.노드시작)136
let 보이는끝 = 작은값(끝, 쪽.노드끝 - 1)137
let mut 순번 = 보이는시작138
while 순번 < 보이는끝 {139
let 지역 = 순번 - 쪽.노드시작140
if 지역 % 12 != 11 && 수직씻김[지역] < 깊이 { 수직씻김[지역] = 깊이 }141
순번 = 순번 + 1142
}143
순번 = 보이는시작144
while 순번 + 12 <= 보이는끝 {145
let 지역 = 순번 - 쪽.노드시작146
if 수평씻김[지역] < 깊이 { 수평씻김[지역] = 깊이 }147
순번 = 순번 + 1148
}149
}150
범위순번 = 범위순번 + 1151
}152
색인 = 0153
while 색인 < 노드수 {154
let 노드 = 노드들[쪽.노드시작 + 색인]155
if 노드.부모순번 >= 0 { 이역할[색인] = 이역할변형(노드.자식필드) }156
if 노드.식별자있음 && 노드.식별자류번호 < 9 { 팔그물[색인] = 노드.식별자류번호 }157
색인 = 색인 + 1158
}159
Ok(그림준비 {160
요청: 요청, 머리: 머리레코드(요청, 계획, 쪽), 머리바이트: 머리바이트,161
보호바이트: 보호바이트, 노드시작: 쪽.노드시작, 노드끝: 쪽.노드끝,162
수직씻김: 수직씻김, 수평씻김: 수평씻김, 이역할: 이역할, 팔그물: 팔그물163
})164
}166
function 크롬색(준비: 그림준비, 가로: int, 세로: int, 바탕: int) -> int {167
if 준비.머리.크롬번호 != 1 { return 바탕 }168
let mut 색 = 바탕169
let 잉크 = 2959909170
let 줄색 = 5458753171
let 제목글자수 = 준비.머리.제목.scalars().length172
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 꼬리위 = 준비.머리.높이 - 64178
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 인장왼쪽 = 1247190
let 인장위 = 준비.머리.높이 - 49191
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
색204
}206
function 그림색(준비: 그림준비, 가로: int, 세로: int) -> int {207
let mut 색 = 15262682208
let 형식색 = 형식팔레트()209
if 가로 >= 78 && 세로 >= 24 {210
let 칸가로 = (가로 - 78) / 2211
let 칸세로 = (세로 - 24) / 2212
if (가로 - 78) % 2 < 2 && (세로 - 24) % 2 < 2 && 칸가로 < 320 {213
let 바이트색인 = 칸세로 * 80 + 칸가로 / 4214
if 바이트색인 < 준비.머리바이트.length() {215
let 부분 = 칸가로 % 4216
let 숫자 = (준비.머리바이트.get(바이트색인) / 거듭제곱이((3 - 부분) * 2)) % 4217
색 = 형식색[숫자]218
}219
}220
}221
let 코드색 = 이미지팔레트(준비.머리.언어번호)222
let mut 색인 = 0223
while 색인 < 코드색.length {224
if 사각안(가로, 세로, 804 + 색인 * 16, 24, 12, 12) { 색 = 코드색[색인] }225
색인 = 색인 + 1226
}227
let 표들 = [이역할팔레트(), 팔그물팔레트(), 범위씻김팔레트()]228
let 왼쪽들 = [804, 884, 964]229
let mut 표번호 = 0230
while 표번호 < 3 {231
색인 = 0232
while 색인 < 표들[표번호].length {233
if 사각안(가로, 세로, 왼쪽들[표번호] + 색인 * 8, 42, 6, 6) { 색 = 표들[표번호][색인] }234
색인 = 색인 + 1235
}236
표번호 = 표번호 + 1237
}238
let 노드수 = 준비.노드끝 - 준비.노드시작239
let 판상대세로 = 세로 - 71240
if 판상대세로 >= 0 {241
let 행 = 판상대세로 / 36242
let 행안 = 판상대세로 % 36243
if 행안 < 30 {244
let 수직상대 = 가로 - 109245
if 수직상대 >= 0 && 수직상대 % 108 < 6 {246
let 열 = 수직상대 / 108247
let 지역 = 행 * 12 + 열248
if 열 < 12 && 지역 < 노드수 && 준비.수직씻김[지역] > 0 {249
색 = 범위씻김팔레트()[작은값(준비.수직씻김[지역], 3) - 1]250
}251
}252
} else {253
let 열상대 = 가로 - 7254
if 열상대 >= 0 {255
let 열 = 열상대 / 108256
let 열안 = 열상대 % 108257
let 지역 = 행 * 12 + 열258
if 열 < 12 && 열안 < 102 && 지역 < 노드수 && 준비.수평씻김[지역] > 0 {259
색 = 범위씻김팔레트()[작은값(준비.수평씻김[지역], 3) - 1]260
}261
}262
}263
}264
let 첫열가로 = 가로 - 55265
let 첫열세로 = 세로 - 65266
if 첫열가로 >= 0 && 첫열가로 < 6 && 첫열세로 >= 0 && 첫열세로 % 36 < 6 {267
let 지역 = (첫열세로 / 36) * 12268
if 지역 < 노드수 && 준비.이역할[지역] >= 0 { 색 = 이역할팔레트()[준비.이역할[지역]] }269
}270
let 역할가로 = 가로 - 1271
let 역할세로 = 세로 - 83272
if 역할가로 >= 0 && 역할세로 >= 0 && 역할가로 % 108 < 6 && 역할세로 % 36 < 6 {273
let 열 = 역할가로 / 108274
let 행 = 역할세로 / 36275
let 지역 = 행 * 12 + 열276
if 열 >= 1 && 열 < 12 && 지역 < 노드수 && 준비.이역할[지역] >= 0 { 색 = 이역할팔레트()[준비.이역할[지역]] }277
}278
let 그물가로 = 가로 - 109279
let 그물세로 = 세로 - 71280
if 그물가로 >= 0 && 그물세로 >= 0 && 그물가로 % 108 < 6 && 그물세로 % 36 < 6 {281
let 열 = 그물가로 / 108282
let 행 = 그물세로 / 36283
let 지역 = 행 * 12 + 열284
if 열 < 12 && 지역 < 노드수 && 준비.팔그물[지역] >= 0 { 색 = 팔그물팔레트()[준비.팔그물[지역]] }285
}286
if 판상대세로 >= 0 && 판상대세로 % 36 < 30 {287
let 열상대 = 가로 - 7288
if 열상대 >= 0 {289
let 열 = 열상대 / 108290
let 열안 = 열상대 % 108291
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) / 2304
let 칸세로 = (세로 - 준비.머리.띠위) / 2305
if 칸가로 < 648 {306
let 바이트색인 = 칸세로 * 162 + 칸가로 / 4307
if 바이트색인 < 준비.보호바이트.length() {308
let 부분 = 칸가로 % 4309
let 숫자 = (준비.보호바이트.get(바이트색인) / 거듭제곱이((3 - 부분) * 2)) % 4310
색 = 띠팔레트()[숫자]311
}312
}313
}314
크롬색(준비, 가로, 세로, 색)315
}317
function 사각채우기(그림: 주사그림, 왼쪽: int, 위: int, 너비: int, 높이: int, 색: int) -> bool {318
let mut 바이트들 = 그림.바이트들319
let 빨강 = (색 / 65536) % 256320
let 초록 = (색 / 256) % 256321
let 파랑 = 색 % 256322
let mut 세로 = 위323
while 세로 < 위 + 높이 {324
let mut 위치 = 세로 * 3913 + 1 + 왼쪽 * 3325
let 끝 = 위치 + 너비 * 3326
while 위치 < 끝 {327
바이트들.set(위치, 빨강); 바이트들.set(위치 + 1, 초록); 바이트들.set(위치 + 2, 파랑)328
위치 = 위치 + 3329
}330
세로 = 세로 + 1331
}332
true333
}335
function 바이트그리기(그림: 주사그림, 바이트들: ByteBuffer, 왼쪽: int, 위: int, 행바이트: int, 칸크기: int, 팔레트: Array<int>) -> bool {336
let mut 색인 = 0337
while 색인 < 바이트들.length() {338
let 행 = 색인 / 행바이트339
let 바이트열 = 색인 % 행바이트340
let 값 = 바이트들.get(색인)341
let mut 부분 = 0342
while 부분 < 4 {343
let 숫자 = (값 / 거듭제곱이((3 - 부분) * 2)) % 4344
사각채우기(그림, 왼쪽 + (바이트열 * 4 + 부분) * 칸크기, 위 + 행 * 칸크기, 칸크기, 칸크기, 팔레트[숫자])345
부분 = 부분 + 1346
}347
색인 = 색인 + 1348
}349
true350
}352
function 글자그리기(그림: 주사그림, 글: string, 왼쪽: int, 위: int, 배율: int, 색: int) -> bool {353
let 글자들 = 글.scalars()354
let mut 글자색인 = 0355
while 글자색인 < 글자들.length {356
let 모양 = 픽셀글꼴(글자들[글자색인]).scalars()357
let mut 행 = 0358
while 행 < 5 {359
let mut 열 = 0360
while 열 < 3 {361
if 모양[행 * 3 + 열] == "1" {362
사각채우기(그림, 왼쪽 + 글자색인 * 4 * 배율 + 열 * 배율, 위 + 행 * 배율, 배율, 배율, 색)363
}364
열 = 열 + 1365
}366
행 = 행 + 1367
}368
글자색인 = 글자색인 + 1369
}370
true371
}373
function 책크롬그리기(그림: 주사그림) -> bool {374
let 머리 = 그림.준비.머리375
let 잉크 = 2959909376
let 줄색 = 5458753377
let 제목길이 = 머리.제목.scalars().length378
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 꼬리위 = 머리.높이 - 64384
사각채우기(그림, 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 인장왼쪽 = 1247396
let 인장위 = 머리.높이 - 49397
let 인장색 = 12466730398
사각채우기(그림, 인장왼쪽, 인장위, 36, 1, 인장색); 사각채우기(그림, 인장왼쪽, 인장위 + 35, 36, 1, 인장색)399
사각채우기(그림, 인장왼쪽, 인장위, 1, 36, 인장색); 사각채우기(그림, 인장왼쪽 + 35, 인장위, 1, 36, 인장색)400
let 해시글자 = 머리.세트해시.scalars()401
let mut 비트 = 0402
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
비트 = 비트 + 1408
}409
true410
}412
function 주사그림만들기(준비: 그림준비) -> 주사그림 {413
let mut 바이트들 = ByteBuffer.allocate(3913 * 준비.머리.높이)414
let mut 가로 = 0415
while 가로 < 1304 {416
let 위치 = 1 + 가로 * 3417
바이트들.set(위치, 232); 바이트들.set(위치 + 1, 227); 바이트들.set(위치 + 2, 218)418
가로 = 가로 + 1419
}420
let mut 세로 = 1421
while 세로 < 준비.머리.높이 { 바이트들.copy(바이트들, 0, 세로 * 3913, 3913); 세로 = 세로 + 1 }422
let 그림 = 주사그림 { 준비: 준비, 바이트들: 바이트들 }423
바이트그리기(그림, 준비.머리바이트, 78, 24, 80, 2, 형식팔레트())424
let 코드색 = 이미지팔레트(준비.머리.언어번호)425
let mut 색인 = 0426
while 색인 < 코드색.length { 사각채우기(그림, 804 + 색인 * 16, 24, 12, 12, 코드색[색인]); 색인 = 색인 + 1 }427
let 표들 = [이역할팔레트(), 팔그물팔레트(), 범위씻김팔레트()]428
let 왼쪽들 = [804, 884, 964]429
let mut 표번호 = 0430
while 표번호 < 3 {431
색인 = 0432
while 색인 < 표들[표번호].length {433
사각채우기(그림, 왼쪽들[표번호] + 색인 * 8, 42, 6, 6, 표들[표번호][색인])434
색인 = 색인 + 1435
}436
표번호 = 표번호 + 1437
}438
let 노드수 = 준비.노드끝 - 준비.노드시작439
색인 = 0440
while 색인 < 노드수 {441
let 행 = 색인 / 12442
let 열 = 색인 % 12443
let 왼쪽 = 7 + 열 * 108444
let 위 = 71 + 행 * 36445
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 칸 = 0463
while 칸 < 3 {464
사각채우기(그림, 왼쪽 + 칸왼쪽들[칸], 위, 30, 30, 코드색[숫자들[칸]])465
칸 = 칸 + 1466
}467
색인 = 색인 + 1468
}469
바이트그리기(그림, 준비.보호바이트, 4, 준비.머리.띠위, 162, 2, 띠팔레트())470
if 준비.머리.크롬번호 == 1 { 책크롬그리기(그림) }471
그림472
}474
function 고정디플레이트(그림: 주사그림) -> Result<Bytes, string> {475
그림.바이트들.toBytes().deflateFixedCompress()476
}478
export 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 위치 = 0494
결과.copy(서명, 0, 위치, 서명.length()); 위치 = 위치 + 서명.length()495
결과.copy(아이헤더, 0, 위치, 아이헤더.length()); 위치 = 위치 + 아이헤더.length()496
결과.copy(아이데이터, 0, 위치, 아이데이터.length()); 위치 = 위치 + 아이데이터.length()497
결과.copy(아이끝, 0, 위치, 아이끝.length())498
Ok(결과.toBytes())499
}SHA256 8ec630bcdac3dffd9d5b8eec79bd5b902670e45a4663280eff2626813c674e0e