数学建模社区-数学中国

标题: python将红底证件照转成蓝底 [打印本页]

---

作者: 杨利霞    时间: 2022-9-7 11:41
标题: python将红底证件照转成蓝底
python将红底证件照转成蓝底
: h  S) W# [: I6 p1 k& E, Q前言
emmm…快开学了，手头只有红底证件照，但是学院要求要蓝底，这可咋办呢。懒得下ps了。自己撸起来吧。
" d3 T: O5 K/ ]7 W4 y1 F) j
/ a" |  u& {) [# h. b+ v2 {2 l
9 N) l* J6 C) }) m# r

! U( V9 {/ M7 V6 n; w8 {% J7 _  }3 t方法一: lableme
lableme标注完后。得到一个json文件，然后将这种json文件转成掩码图.
1 l- i/ r: E% Z# [
0 Z' L. u# q( \7 {$ ?# 代码来自 https://blog.csdn.net/hello_dear_you/article/details/120130155
import json
. d- h+ Z2 s' ~" G+ y( l1 T  Fimport numpy as np
import cv2
6 e& a; S! `# h8 X# n- {# read json file
3 D; J( B: z% K: G  b9 i' a4 jwith open("origin_json/mypic.json", "r") as f:
' w+ p4 V+ t  J4 p    data = f.read()
# Y: O+ z4 G7 H) d) R, b  `
# convert str to json objs
# C0 w$ y. z: S' w6 U* h7 sdata = json.loads(data)

# get the points
9 g1 B( d3 K& T& P' ]points = data["shapes"][0]["points"]
* h( A9 }% ^2 i# n7 Opoints = np.array(points, dtype=np.int32)   # tips: points location must be int32

# read image to get shape
image = cv2.imread("origin_png/person.jpg")
0 O; t( m2 ^- w  x) I
1 x) Y" U8 p: O  _6 s5 ~# create a blank image
mask = np.zeros_like(image, dtype=np.uint8)

# fill the contour with 255
cv2.fillPoly(mask, [points], (255, 255, 255))

# save the mask
: {, J+ b, D/ n, Y) q) t' Y1 mcv2.imwrite("mask/person_mask.png", mask)
2 U) S5 U+ x- a4 L- A- p1
2
& w- w# i8 K* h& T$ c3
4
7 z+ I: t) v" N' k8 x$ `& ?2 B$ H5
- o% Y. F( e2 ?, E) i$ ]6 k0 d6
  r" o1 l) }. `0 i& K7
8 q& Q: M* }* b: g, g. p; p& {1 h! i1 a8
% _9 y# x) {' }" Q+ m9
10
11
) c6 ]$ y+ D0 W" I) {& P5 T1 A# C12
13
14
$ @3 e0 Y! |% I, L0 t7 w2 H- v15
6 A9 [' X5 z2 H4 |: U( t16
8 ?: C' T$ Y' `4 t8 z1 k17
& ^4 o/ }" }1 f/ |; e1 a4 E18
$ q6 n; ?6 X. Z; w9 H# u5 G8 u) P+ q19
! V  G5 f% A3 g$ Y4 f20
21
0 g8 a- O, C, B: S: K$ }22
23
$ n5 p# O  M2 F9 K( ]+ ~3 Q/ g2 s6 u24
25
26
大概是这样:
6 g2 ]$ P8 p+ ]! }: s  b
3 y) G2 K6 T5 X* Y: w* c
: k  }2 H; f" r4 e6 l' K- T2 _. i% e然后利用这个mask生成图片
) w0 ?! m2 o+ u+ l
# 参考自: https://www.jianshu.com/p/1961aa0c02ee
import cv2
import numpy as np
$ I# S3 `7 h8 S( R2 z1 O! U

origin_png = 'origin_png/person.jpg'
1 A% f) z3 r) w! s# maskPath = 'mask/person_mask.png'
maskPath = 'mask/bmv2.png'
+ s) L. N' j4 L/ ^result_png = 'result_png/result_png.png'
% s7 i- {5 ]* f# m$ {; {
/ o' Z( B9 {4 z
0 X- S) R$ C' I( y$ f  a$ b% bmaskImg = cv2.imread(maskPath)
2 W1 b' l$ a  i0 I& {- Bimg = cv2.imread(origin_png)
assert maskImg.shape == img.shape, 'maskImg.shape != origin_png.shape'

6 B; m) e2 G( B/ ^h, w = img.shape[0], img.shape[1]
' Z* F6 d0 l& tprint('图片宽度: {}, 高度: {}'.format(h, w))
% U3 }3 l$ L8 n9 L, e
% R0 g; j* `, k6 X+ ]rgb = (19,122,171)
bgr = (rgb[2], rgb[1], rgb[0])
# (B, G, R)
for i in range(h):
: Y% s- g; [  D  p# G    for j in range(w):
! m9 \7 k+ O5 Z        if (maskImg[i, j] == 0).all():
            img[i, j] = bgr
cv2.imwrite(result_png, img)
  w' h+ Z' k9 p- L# P, Rprint('图片写入 {} 成功'.format(result_png))
' [% D; I# m! j4 t$ ^* |1
2
3
4
5
6
7
8
9
10
( j3 T. M0 Y- o0 s7 N6 [* K& X+ a11
2 K  K2 w/ ^2 r8 s  i8 i12
13
  f; \! W, r, d1 A1 G14
15
16
17
18
19
20
8 U5 L# q" r' v- l21
, s0 {) I/ K1 U. ]  x3 Y22
23
24
25
. q% G- l' S% m2 F/ O26
" ~9 A2 V" K% A+ R: u  J1 e27
% \% J8 B2 W3 q# Y' p% @& x9 r由于人长得一般，就不放图了…
+ Q5 X. C* I+ y% y% [6 F) X. A
缺点:
' z! C1 q7 O0 k4 Z4 |, Ilableme标注时挺费力，并且难以避免人与背景边缘会有残留红色像素的情况。


& e$ @% H' @6 {/ ?


+ x, W( q8 K1 e4 d  w. S4 g& r5 |方法二: 阈值
4 Y+ d/ W8 k' r$ f1 ~/ e" |7 w该方法通过比较像素的RGB与背景的RGB来区分是否为图像背景。
  p5 `) \& }  C; M, X% }
Opencv
/ r/ n/ T# @2 ~  J5 S  Zimport cv2
9 K9 f. c: g3 {8 v0 \7 ^- u- l7 U% kimport numpy as np


def mean_square_loss(a_np, b_np):
    sl = np.square(a_np - b_np)
0 R0 \3 L4 \: l( {  F' D    return np.mean(sl)
  _. o- X. |( ?2 T: H/ v# X6 M

def change_red2blue(origin_png, result_png):
+ g' M# D5 X# J" N3 W2 t    img = cv2.imread(origin_png)

6 L9 {; X  \* N: }! G4 Q    h, w = img.shape[0], img.shape[1]
    print('图片宽度: {}, 高度: {}'.format(h, w))
6 F' ]& I+ V- ~% M+ z: _) V" E
    origin_rgb = (168,36,32)  # 可以用浏览器啥的控制台工具提取出背景的rgb值
    origin_bgr = (origin_rgb[2], origin_rgb[1], origin_rgb[0])
2 p9 I: b" C: ?# G* f" Q, A+ v+ `. r    target_rgb = (19,122,171) # 蓝底RBG
; }6 {& x' W  [( k: i) _- C) |3 O- S    target_bgr = (target_rgb[2], target_rgb[1], target_rgb[0])
) F* q. f1 h( v  c
    for i in range(h):
. Q2 Y. ?  A; L- q" Z7 b/ d        for j in range(w):
! _$ Y8 B. d7 |& v            # (B, G, R)
            if mean_square_loss(img[i, j], origin_bgr) < 50:
9 Q0 w/ X* X6 I" ?' i6 Z                img[i, j] = target_bgr
" ~& P& d* r$ x" \
    cv2.imwrite(result_png, img)
    print('图片写入 {} 成功'.format(result_png))


if __name__ == '__main__':
9 i+ o$ t* z0 ]8 M: p! n    # origin_png = 'result_png/result_png.png'
# m3 c8 k% y' ~: G' K    origin_png = 'origin_png/person.jpg'
    result_png = 'result_png/result_refine.png'
    change_red2blue(origin_png, result_png)
' R+ S5 d! i7 o5 D$ p, s1
2
3
0 ~- y* v' b8 x" W) o$ P4
5
  }1 N) q4 z% n7 j0 q7 N6
7
8
9
10
- K( O& K' n( Q11
12
, Y% w' d8 w" J0 r* l  {13
14
/ s. }7 X, V  `5 T15
4 E- Y" g8 d7 {# ]% P  q16
17
18
19
- ^' J/ C4 T& H9 q+ J! j7 b20
21
- o" y' z2 D8 Q. _7 J- X22
23
. f6 E- h! s2 `: N" K3 P24
' K  o  {3 K( y1 n5 Z! {) ]25
26
. ~7 `2 [! q1 u/ _27
28
; V# v. b( j; e9 ~! \* A, g29
30
31
32
33
6 P5 a  ?: r7 `, r: Y34
35
结果人与背景边缘仍会存在红色像素残留
8 ~& K0 \' ]$ Y1 M* t: Z7 {$ }/ d
1 |* B+ p- \6 |, s! `& V1 ]
3 Y; e1 E- b8 n' u3 I3 x

# B2 t( W8 ^- s4 q2 t; j
5 j) a- x# ~' U& o) MPIL
from torchvision.transforms.functional import to_tensor, to_pil_image
- y% g# O: t5 lfrom PIL import Image
import torch
0 _- N4 I; X; M% Y! C0 ^  [import time

( a3 {- m7 u1 s# |' _
2 ^1 i. u  y1 ?7 t5 d3 x8 |  H, Idef mean_square_loss(a_ts, b_ts):
    # print(a_ts.shape)
- N% e& f* e6 z( r# [: f5 x    # print(b_ts)
    sl = (a_ts - b_ts) ** 2
# B4 v3 A/ X! o, V    return sl.sum()


" H7 L: B4 Y3 d3 o7 g0 F" x1 Adef change_red2blue(origin_png, result_png):
    src = Image.open(origin_png)
: b6 c% ^$ U3 Z+ k    src = to_tensor(src)
    # print(src.shape)  # torch.Size([3, 800, 600])
3 P) z, C1 l" l; d: I& u3 k, \9 i    # channel: (R, G, B) / 255
    h, w = src.shape[1], src.shape[2]

$ W, [/ u% r; G( n    pha = torch.ones(h, w, 3)
5 F$ |* G+ F& I/ |; F
* g+ i5 X! S7 B/ r+ _& ]0 K* J    bg = torch.tensor([168,36,32]) / 255
2 q4 ?1 a6 a$ Q    target_bg = torch.tensor([19,122,171]) / 255

0 @+ a4 L6 G: @- O" G& H2 i' _+ M    # C, H, W -> H, W, C
    src = src.permute(1, 2, 0)
5 H% @5 A$ U3 k1 ?, n+ H    for i in range(h):
+ u  g1 D# A1 v- I9 c        for j in range(w):
9 Q% h' t. t/ ~5 X: D4 i9 x4 L7 C            if mean_square_loss(src[j], bg) < 0.025: # 0.025是阈值，超参数
0 r" O! i0 w% g# e/ ]* u/ z2 j                pha[j] = torch.tensor([0.0, 0.0, 0.0])
0 l' h# {& b1 }+ I
2 |$ j1 f# B) l- b  O9 g    # H, W, C -> C, H, W
    src = src.permute(2, 0, 1)
6 Z( T7 O5 o# ?. Z- R- o    pha = pha.permute(2, 0, 1)
    com = pha * src + (1 - pha) * target_bg.view(3, 1, 1)
$ k2 R2 D) X( n6 t, b    to_pil_image(com).save(result_png)

/ h4 o2 U' X' {  Z9 q
% q) f# j2 t0 D. ]) a. E( Z  qif __name__ == '__main__':
3 g! Z: C! q) y; t$ @    origin_png = 'origin_png/person.jpg'
$ @; ~9 e. o2 N' ?' J$ ~: L6 T    result_png = 'result_png/com.png'
    start_time = time.time()
    change_red2blue(origin_png, result_png)
    spend_time = round(time.time() - start_time, 2)
+ k; V7 a- j) \0 y- ^7 U    print('生成成功，共花了 {} 秒'.format(spend_time))
" v0 q- R, g  E" h7 v2 r8 w7 V4 R1
2
3
5 Z+ |- i: K9 e4
5
6
7
8
9
10
11
12
- k: E9 b1 Q/ z7 c/ b9 e13
14
6 Z/ q: |" w) y  N/ x# s1 N6 ]9 Z1 `15
: o5 r+ d! W0 g1 J1 Z1 [3 y16
) F4 l2 f" m$ S2 ^# x3 O$ B! C17
18
19
- p4 T" u! n. u: T, L1 P20
. D- W0 b6 c/ e7 x* m+ @) i0 Y21
22
* g% r, c. D. z% g4 P2 B* Z/ B23
24
* W; {5 F7 ^5 x/ [! V. P( ]25
26
27
28
- M% X8 \, ~+ P29
3 _! ]" Q: A( |( {% v8 S30
31
- J+ q, I% f  `32
1 ^8 f  ~. S0 D33
  L3 j; v1 ^' k34
35
( t' e0 ]) r( }  G# v/ R36
37
38
# o& j. U; b# X' B. h3 b39
- J# ]# K2 E+ p& |40
( `4 k% B, u& x& X2 f" s41
42
43
3 E9 c; v3 z2 d44
45
; D4 h$ e: n! T; t* a* m46
0 \: {1 Z* t/ O* Y. y9 s: p  {4 f该方法质量较好，但一张图片大概需要12秒。
2 s! e+ }* S& ?1 J


4 I3 q/ [& H  i  |5 |& f9 ^方法四： Background MattingV2
Real-Time High-Resolution Background Matting
- p4 y# T7 J* D: F5 g7 Z4 u, |# F: M6 k4 `CVPR 2021 oral

3 H) m" ?- \3 j9 R2 k论文：https://arxiv.org/abs/2012.07810
6 z" h& {# W1 W1 e0 y代码：https://github.com/PeterL1n/BackgroundMattingV2

$ ?  a' w; i- L( ?- G* t6 T( lgithub的readme.md有inference的colab链接，可以用那个跑
" ^% |9 x# ~) O" v: B) K! p
由于这篇论文是需要输入一张图片(例如有人存在的草地上)和背景图片的(如果草地啥的)， 然后模型会把人抠出来。
7 B1 D' E( i+ @! ~
于是这里我需要生成一个背景图片。
首先我先借助firefox的颜色拾取器（或者微信截图，或者一些在线工具，例如菜鸟工具），得到十六进制，再用在线转换工具转成rgb。

然后生成一个背景图片。

& |, X7 [7 G7 S! T7 T7 K- d0 A( dimport cv2
import numpy as np


2 t% C! B2 I2 K& w1 w' iimage = cv2.imread("origin_png/person.jpg")
origin_rgb = (168,36,32)  # 可以用浏览器啥的控制台工具提取出背景的rgb值
# J6 h8 u% F9 q1 T  `3 Q8 g; {+ n9 Zorigin_bgr = (origin_rgb[2], origin_rgb[1], origin_rgb[0])
9 i& T+ F% l9 n4 h( ?* I- m) Iimage[:, :] = origin_bgr
% q" {! ^" X6 w) P& R; g9 ?7 @3 y
cv2.imwrite("mask/bg.png", image)
) C( A; ]* ~5 ]6 l3 U1
* o: Z( w2 L9 E/ d. S0 N" u( e/ h2
/ d5 v: @4 M( M5 X3
4
5
4 X$ I3 R8 Y0 d: D9 e: O6
0 K3 H3 i' Q7 S0 @: E$ I  [7
8 s0 o/ h& J* R( p! t8
9
+ J4 |' k/ `+ F: O" h3 |10

/ b" v7 h6 h+ G$ |! ~. N% \- W需要上传人的照片和背景照片, 如果名字和路径不一样则需要修改一下代码

src = Image.open('src.png')
bgr = Image.open('bgr.png')
  i( s  ^2 x' c1
- `4 O) w' l# Z, K9 ]+ P2
3 l0 u7 z1 F; B+ i9 a* p另外原论文是边绿底，要变蓝底，白底，红底则可以修改RGB值，举个例子，原来是这样的(绿底, RGB120, 255, 155)
) J) k. c) E5 ]5 E
0 @1 Z! f) k) ~; n1 D! Y* hcom = pha * fgr + (1 - pha) * torch.tensor([120/255, 255/255, 155/255], device='cuda').view(1, 3, 1, 1)
( Y  n6 Y) K1 W' ]# J& n1
* F) A) Z2 i" S2 u, ^
那么加入我要换白底(255, 255, 255)，就是

com = pha * fgr + (1 - pha) * torch.tensor([255/255, 255/255, 255/255], device='cuda').view(1, 3, 1, 1)
1

0 r' `1 @! ^) s) `, _. Z, Z: i假如像我换蓝底(19,122,171)具体深浅可以调节一下RGB，就是

# F4 _7 k$ y0 ]) ~! w4 C5 ucom = pha * fgr + (1 - pha) * torch.tensor([19/255, 122/255, 171/255], device='cuda').view(1, 3, 1, 1)
2 [7 r! e) b+ @1
总结: 其实这种方法从 任何颜色的照片 都可以 换成任何颜色的底。只要换下RGB.
, w& j: Y! [+ j' c, R. M
然后就输出图片了。可以看到效果相当好。不愧是oral。
3 Y! d  C$ J6 ]8 r. c
, y4 U& W" e1 W* h& Z8 W; |
5 d5 S5 D) D; M  }原论文可以实现发丝级效果
  J. F. p; K9 h. Q' t1 y
+ P1 w$ _# `. n0 @& h3 Y5 e1 y% {5 U
0 m7 o* l- k0 t! L: j" F
: m( [7 D! B# a: X4 s* ^( v1 X

报错解决方案
can’t divided by 4 / can’t divided by 16
由于该骨干模型可能进行4倍或16倍下采样，因此如果您的证件照不是该倍数的话，有两种选择方案。一种是padding, 填充后再送入模型，然后出结果后再用clip函数裁剪。另一种方式是resize, 给resize到规定倍数的宽和高。
" Z7 H0 B4 `" b( `8 m& ]) Y5 Z这两种方案需要的代码都可以从这篇博文找到: python图像填充与裁剪/resize
- E7 f. h( c! ]4 k————————————————
版权声明：本文为CSDN博主「Andy Dennis」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43850253/article/details/126376767
. t, p  I+ o7 Y8 v& U/ m8 c% b+ i

# [0 m* T+ z) T/ a+ |6 [4 e

---

欢迎光临 数学建模社区-数学中国 (http://www.madio.net/)

Powered by Discuz! X2.5