python将红底证件照转成蓝底

杨利霞

python将红底证件照转成蓝底
" C( N  l( n; q前言
, D1 u' b( x, t. c* Pemmm…快开学了，手头只有红底证件照，但是学院要求要蓝底，这可咋办呢。懒得下ps了。自己撸起来吧。
1 F/ Q& T; i3 @. E# H
9 m& E( L3 k) p) S$ I( T, b) m) Z
+ c2 |3 J5 b$ D' F
0 }1 \& Q1 w  f+ X
方法一: lableme
0 o( w- ?2 Y2 ^9 g& e) c1 m1 f) f- [lableme标注完后。得到一个json文件，然后将这种json文件转成掩码图.
& Z+ Z1 f7 c2 N- i9 C1 b
) V1 X6 N- Q% j; i' h, \# 代码来自 https://blog.csdn.net/hello_dear_you/article/details/120130155
0 e2 R/ e1 P0 S7 I! Y* K8 ^  g8 cimport json
  a) X& S" B5 b$ O( b' l# Simport numpy as np
import cv2
# read json file
4 o, U* Q1 x' E2 Z( Gwith open("origin_json/mypic.json", "r") as f:
    data = f.read()

# convert str to json objs
data = json.loads(data)
+ |% x$ r! N4 q/ L% s, V7 |
# get the points
points = data["shapes"][0]["points"]
6 Q! t9 t3 \# U: rpoints = np.array(points, dtype=np.int32)   # tips: points location must be int32

4 c7 L/ o6 h' i5 \8 z# read image to get shape
* z9 V) S6 |" m; Z# P4 c4 A) K" K) limage = cv2.imread("origin_png/person.jpg")

# create a blank image
& K3 e; L5 w1 q0 Z- Lmask = np.zeros_like(image, dtype=np.uint8)
& `- q$ T  d5 R3 z; @+ P
% d: g& V! H+ g9 }" g  o. d. q# fill the contour with 255
cv2.fillPoly(mask, [points], (255, 255, 255))

2 m8 T1 f" a7 ?# save the mask
cv2.imwrite("mask/person_mask.png", mask)
. o8 R. k6 S1 ~$ M2 s  b0 h5 N1
2
' y  u) D( E) I2 K) e  c- Z0 M; W3
5 G% E2 G1 [  x. a& C3 D* Y- B4
5
6
7
# P# i4 g1 s6 X+ U& \/ k; Q8
* }/ u6 }( t; `1 F  P9
10
2 {3 o0 g: }; J. w: z3 X11
12
13
) H" c4 I9 }3 E! x14
! M# j4 c9 j- v9 p' l2 Z! J15
16
17
: c5 x/ n( q- B5 N8 C. r& @18
6 O. B* K- t+ X0 p6 |19
20
3 p5 |* Y8 n* T9 @8 z21
# f1 o* q) x2 S' i22
23
24
25
  F" ~* U% S5 x- u3 h: }8 o26
大概是这样:


然后利用这个mask生成图片
' U  Y: y  N1 Y' {
# 参考自: https://www.jianshu.com/p/1961aa0c02ee
import cv2
6 v1 a7 j2 d" i. Q5 u3 Z  |8 aimport numpy as np
( r$ L* ]! i2 b- g* X" U

origin_png = 'origin_png/person.jpg'
8 z* Q5 M: `7 J$ |; p, U# maskPath = 'mask/person_mask.png'
; O, V' {2 J0 w$ YmaskPath = 'mask/bmv2.png'
result_png = 'result_png/result_png.png'
% x- u. K7 ?" a4 Y& l; g% V3 V
1 q6 [1 r  r4 s' ^4 f* T5 W" O: X8 Y
' K7 d3 @5 g5 q8 h. U" n+ d$ KmaskImg = cv2.imread(maskPath)
img = cv2.imread(origin_png)
assert maskImg.shape == img.shape, 'maskImg.shape != origin_png.shape'
  z/ ^1 E( i6 j& t8 B- \
( Z! m/ d* E% [5 o) p1 H; p2 mh, w = img.shape[0], img.shape[1]
print('图片宽度: {}, 高度: {}'.format(h, w))
, {2 J  W% F" u5 m" p, ^
" K& ~; h; l4 nrgb = (19,122,171)
; B8 _8 {1 L; n1 Pbgr = (rgb[2], rgb[1], rgb[0])
9 i; p! h* ^1 }2 M) G- |& F# _# (B, G, R)
% v' j3 T$ ~, Y% f5 ?  hfor i in range(h):
    for j in range(w):
        if (maskImg[i, j] == 0).all():
            img[i, j] = bgr
cv2.imwrite(result_png, img)
2 _0 m9 T* k8 n0 h, Iprint('图片写入 {} 成功'.format(result_png))
% w- f6 P+ J0 c. X1
: I6 R# S, {( s0 O2 v% z: n& e2
3
* X1 `/ R) \  X4
5
. h2 r3 T6 Q- N# i- c3 l6
  W* n* L* [2 D& W( S  k  [7
2 J: k/ z7 G0 }* t1 N8
' S% }# J* j; R- M  Q/ C9
10
* B; M2 u! }% P  @, c3 W$ M8 ^11
12
13
14
15
2 t$ n5 `! w: c- m$ a16
! Q: Q6 l! f" z) x- ~17
18
19
20
21
22
  k  @% O5 v9 d) `23
24
25
, j3 r* J' ^. @  o) C26
27
3 V/ q& r. a  H$ ]: k由于人长得一般，就不放图了…
) L* q: d2 o) z; s8 d* T
: G. G2 h3 b! t/ Z) N. `缺点:
, m: Q0 [2 r) ~2 m7 v, R* Plableme标注时挺费力，并且难以避免人与背景边缘会有残留红色像素的情况。
7 [5 u4 E( }; U% L1 b. n5 Q
, ]* E! e1 ^7 C+ Q: x4 |

5 V: }4 X4 F' }* I: n6 y
3 S7 f' R2 d$ V
方法二: 阈值
3 E$ [  c' {2 l/ z$ V该方法通过比较像素的RGB与背景的RGB来区分是否为图像背景。
+ [4 b& \0 ~: r/ K: j
! h8 k& d2 U- X. V5 o- q) y, YOpencv
$ B; f/ z' j: E9 vimport cv2
; D+ S- d1 Z% w. I6 \7 m6 `import numpy as np


def mean_square_loss(a_np, b_np):
8 U9 |# u% w9 i7 @  d! l    sl = np.square(a_np - b_np)
2 r( p) i, @$ i8 j' F    return np.mean(sl)
; U5 r: }. F% j, r
: j4 T$ x' C# {  ]5 k7 f8 k
def change_red2blue(origin_png, result_png):
0 Q/ a8 |. Q  k1 T3 T! c    img = cv2.imread(origin_png)

    h, w = img.shape[0], img.shape[1]
6 t- T9 h9 d+ j    print('图片宽度: {}, 高度: {}'.format(h, w))
- K8 Z  p. M# U6 X
    origin_rgb = (168,36,32)  # 可以用浏览器啥的控制台工具提取出背景的rgb值
    origin_bgr = (origin_rgb[2], origin_rgb[1], origin_rgb[0])
7 E; A" @- ?/ w" u/ r  P& |2 U    target_rgb = (19,122,171) # 蓝底RBG
    target_bgr = (target_rgb[2], target_rgb[1], target_rgb[0])
$ h6 k( \3 f$ ^; H; U5 p( j
- h1 R: n  d# f, a' J6 l    for i in range(h):
        for j in range(w):
  c: b% N6 X" [: y            # (B, G, R)
            if mean_square_loss(img[i, j], origin_bgr) < 50:
6 _  L* e9 J$ ?2 n8 X9 z                img[i, j] = target_bgr

    cv2.imwrite(result_png, img)
    print('图片写入 {} 成功'.format(result_png))

( v4 X' [8 L9 ?, c0 ^
if __name__ == '__main__':
    # origin_png = 'result_png/result_png.png'
3 _9 p7 z( c+ f1 z; @    origin_png = 'origin_png/person.jpg'
    result_png = 'result_png/result_refine.png'
/ u8 R% x7 I9 F1 C    change_red2blue(origin_png, result_png)
  X. t; w1 k9 m* C3 c1
0 I; Z! {4 A5 N) N, G2 n) M2
3
& b4 f* ~+ B* p: J  r4 m4 Z4
/ G# o, h& Z, v  w' _5
6
7
8
9
1 G4 s9 H2 D& M2 ~10
/ \, z8 D" V7 }$ U# Z; V11
12
13
14
15
16
+ K: D/ L+ d% M, r17
! K, c0 W; H% m7 I( I18
4 V/ o9 _  L; U0 Q9 F, q/ ]19
20
21
: J/ a3 }" x0 W" Q' O22
+ l0 |( B: e5 A' G5 q23
24
% r: [% v1 L3 V4 Q! K+ H25
- ]& {7 A7 B( r) \26
6 D( r) ~3 K" M) ^27
8 `( L9 x$ {' I28
29
2 V& @+ L4 c, A* V30
% Y# V- ~5 j* c31
32
& a8 Z# K: _1 i6 g6 a5 E. q33
34
35
/ F8 D, [8 o% Y6 b结果人与背景边缘仍会存在红色像素残留



8 o4 l0 `8 j+ \# t9 K5 x6 P- N
3 N; v& D6 S2 |+ `6 s/ _
9 w& F6 T" V9 w+ q. K8 qPIL
from torchvision.transforms.functional import to_tensor, to_pil_image
from PIL import Image
import torch
import time
8 f& w0 X' O5 p" F; I; {; E; d
* O, M! C) V; ?% a) p. w2 V
' r" |" g1 ~! v: u& Adef mean_square_loss(a_ts, b_ts):
    # print(a_ts.shape)
7 k, `  P+ t: Z/ O% ]4 Z    # print(b_ts)
    sl = (a_ts - b_ts) ** 2
0 I) S% |4 f* R3 x+ d    return sl.sum()

1 r. b; N+ z, {$ t( a6 q7 r) M5 q
( n- q7 ~% s( \' n, _def change_red2blue(origin_png, result_png):
    src = Image.open(origin_png)
& `: |, A  `- k5 E6 a$ E# `    src = to_tensor(src)
    # print(src.shape)  # torch.Size([3, 800, 600])
    # channel: (R, G, B) / 255
    h, w = src.shape[1], src.shape[2]
; S4 Y$ f7 a8 n3 y
    pha = torch.ones(h, w, 3)
8 C1 \' Y* q& w% ~8 S, r4 Z- P
, C: l9 O$ {6 F* p/ P& ?4 \    bg = torch.tensor([168,36,32]) / 255
# `7 B& v3 J3 b# @/ t    target_bg = torch.tensor([19,122,171]) / 255

; P: d4 M* w7 @2 T6 A- e6 R1 h1 N    # C, H, W -> H, W, C
3 [: P8 R% q+ ~1 |1 S    src = src.permute(1, 2, 0)
& L2 [' s7 o+ _. S& o3 Z2 P5 m! W% [    for i in range(h):
        for j in range(w):
            if mean_square_loss(src[j], bg) < 0.025: # 0.025是阈值，超参数
( E( a4 U5 K% ?, E0 T/ ]                pha[j] = torch.tensor([0.0, 0.0, 0.0])
0 X7 L5 [2 o& f+ @7 C% Q, s# O
; z, o5 ?6 ^/ g$ ]1 x! o3 W    # H, W, C -> C, H, W
    src = src.permute(2, 0, 1)
    pha = pha.permute(2, 0, 1)
+ ~  o8 K# Y# G    com = pha * src + (1 - pha) * target_bg.view(3, 1, 1)
    to_pil_image(com).save(result_png)

, W; a+ f) t0 J. c; x7 `* |
if __name__ == '__main__':
    origin_png = 'origin_png/person.jpg'
9 X3 d7 I/ t8 l/ N    result_png = 'result_png/com.png'
4 c" \9 J9 ^6 U. X    start_time = time.time()
    change_red2blue(origin_png, result_png)
' M9 ^5 x5 m2 _4 q9 H; C2 @% N5 h    spend_time = round(time.time() - start_time, 2)
- v% L. T" f' E9 t5 r    print('生成成功，共花了 {} 秒'.format(spend_time))
/ F6 e4 b. L, Y- n' u9 l6 H8 b0 S1
: m0 E& {1 B. m2 r. `2
) Z; [5 ]5 e; }$ L6 k3
4
8 \" q& s0 z8 @+ _% q* {, R4 ^8 ?5
# k$ Q% ]/ }2 X; @) _6 x! T8 S! o6
7
1 e5 P$ N2 k0 p+ y9 R/ M! V8
9
10
4 Z7 C6 t% N9 L+ M, G& a11
6 A7 p6 P; r3 N# L2 g12
; O+ Y, Q% m7 o! }$ j13
: L% G! X: c* k* t. N14
15
16
8 n& y- C0 p3 d! g6 ?1 ?% \5 m* K17
  S3 H" ^9 f; Q  ~: t: ^18
1 D" }% `% q5 s: n19
20
21
: q$ v6 P$ G' I9 G5 [/ |7 C6 s) K22
23
24
25
) C) t: d+ O5 K% B1 t26
% K3 H- @2 r( D# O8 e- N27
7 B4 e3 `- n; }* u8 f28
- x- i# m# P3 x6 f1 P, ?1 c1 ~29
30
" Q9 Q4 e: ?: }& _- V31
# |3 c: q  }( h! p' k32
7 r) A0 G7 @: d" A4 u33
& ~' s) z" @2 d% p34
35
4 o7 J& U4 n" |; s: ^3 s$ v# t36
37
" y8 G+ `0 G  U38
) W6 v1 @7 p, h: `& s% p+ p8 e39
40
+ ]( |% q! ]% G3 H3 I41
42
+ G1 J) \4 b) W1 z" n! g43
44
45
46
8 p4 v" f  _- q& j9 D0 r9 e# u- a该方法质量较好，但一张图片大概需要12秒。

3 k% J; g! y8 ]! y2 f

方法四： Background MattingV2
Real-Time High-Resolution Background Matting
# t+ d) ~& D& R* v+ `CVPR 2021 oral
  \/ m% z7 ?5 b4 [
* @8 o1 E$ W1 h' p! _* x. P论文：https://arxiv.org/abs/2012.07810
% S3 y" Z. N3 @; o& T6 v# `7 r& r代码：https://github.com/PeterL1n/BackgroundMattingV2
5 k1 G0 U7 E  R
github的readme.md有inference的colab链接，可以用那个跑

0 y  N) \7 J8 l" z8 e" Z9 X  i5 ?由于这篇论文是需要输入一张图片(例如有人存在的草地上)和背景图片的(如果草地啥的)， 然后模型会把人抠出来。
/ p, [. E( O0 v
于是这里我需要生成一个背景图片。
首先我先借助firefox的颜色拾取器（或者微信截图，或者一些在线工具，例如菜鸟工具），得到十六进制，再用在线转换工具转成rgb。
3 w9 F& `9 E* e2 _/ @  i
( j/ e# v/ ^: }# ]然后生成一个背景图片。
* n6 i4 ]. n1 ]( f
import cv2
. B6 e, I. v9 v/ Y* ~: z" ^( uimport numpy as np
" B" ~! R( |* V
9 ]) @- m# Z* c8 t, p( I0 r6 F
. ^2 g5 |% _7 u% y/ t; G% [. Qimage = cv2.imread("origin_png/person.jpg")
origin_rgb = (168,36,32)  # 可以用浏览器啥的控制台工具提取出背景的rgb值
: L- V9 ?5 M+ G& ?# O* A+ V& |origin_bgr = (origin_rgb[2], origin_rgb[1], origin_rgb[0])
image[:, :] = origin_bgr

* h; u4 H: n8 xcv2.imwrite("mask/bg.png", image)
/ o( m' |0 o0 V  [1
2
, v. n8 G2 i6 B& E! ]4 ]3
4
  l1 l: e4 e' }. [% I5
6
7
8
7 c9 M2 K1 b2 E0 k4 T! [5 [8 Y9
' Q' i# g! Q8 A' m+ }6 |* ^9 G. e10

需要上传人的照片和背景照片, 如果名字和路径不一样则需要修改一下代码

src = Image.open('src.png')
1 J% F" K5 P# t" tbgr = Image.open('bgr.png')
7 F  r( t  i# g# n9 o) {  P1
2
$ {: V+ x' ^$ l6 v另外原论文是边绿底，要变蓝底，白底，红底则可以修改RGB值，举个例子，原来是这样的(绿底, RGB120, 255, 155)
, v* D# X, A  p; E4 Z* p
com = pha * fgr + (1 - pha) * torch.tensor([120/255, 255/255, 155/255], device='cuda').view(1, 3, 1, 1)
$ B5 E. r9 k0 t/ i  Y1

% @; r& X; T* z% b; _5 A那么加入我要换白底(255, 255, 255)，就是
, u3 Y8 }4 W3 Q' D
: ^" ~% t7 o' \/ J' |* s  ]1 ccom = pha * fgr + (1 - pha) * torch.tensor([255/255, 255/255, 255/255], device='cuda').view(1, 3, 1, 1)
1 w5 J2 Y  \4 f5 [7 u1

假如像我换蓝底(19,122,171)具体深浅可以调节一下RGB，就是

com = pha * fgr + (1 - pha) * torch.tensor([19/255, 122/255, 171/255], device='cuda').view(1, 3, 1, 1)
1
5 O* X5 }/ e6 F, _  \- ^- ~# p8 G" G总结: 其实这种方法从 任何颜色的照片 都可以 换成任何颜色的底。只要换下RGB.

0 h! {3 F& V  a5 Y然后就输出图片了。可以看到效果相当好。不愧是oral。

$ {( X3 g: }" W) o# @, n# Z
+ S7 p0 b' V( w. m& p原论文可以实现发丝级效果
  ~: y# {2 c3 q
$ z9 L# z, n1 O; B  D

2 b& r5 q2 N. u" k: H! a9 F! P
( s! A  z* ?( F( \
报错解决方案
2 D% J2 a/ f0 G- @9 w7 y$ G* H# [can’t divided by 4 / can’t divided by 16
由于该骨干模型可能进行4倍或16倍下采样，因此如果您的证件照不是该倍数的话，有两种选择方案。一种是padding, 填充后再送入模型，然后出结果后再用clip函数裁剪。另一种方式是resize, 给resize到规定倍数的宽和高。
这两种方案需要的代码都可以从这篇博文找到: python图像填充与裁剪/resize
* _; N3 Z! e( h————————————————
版权声明：本文为CSDN博主「Andy Dennis」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43850253/article/details/126376767
: ^6 q5 A6 Z. X) U4 a  d. Y

9 n: n8 }% M# y& R1 _9 V