utils.py 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941
  1. import re
  2. import cv2
  3. import sys
  4. import numpy as np
  5. import importlib
  6. from PIL import Image
  7. REGEX_NODE = re.compile(r'(-?[A-Za-z]+)(-?\d+)')
  8. def random_normal_distribution_int(a, b, n=3):
  9. """Generate a normal distribution int within the interval. Use the average value of several random numbers to
  10. simulate normal distribution.
  11. Args:
  12. a (int): The minimum of the interval.
  13. b (int): The maximum of the interval.
  14. n (int): The amount of numbers in simulation. Default to 3.
  15. Returns:
  16. int
  17. """
  18. if a < b:
  19. output = np.mean(np.random.randint(a, b, size=n))
  20. return int(output.round())
  21. else:
  22. return b
  23. def random_rectangle_point(area, n=3):
  24. """Choose a random point in an area.
  25. Args:
  26. area: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  27. n (int): The amount of numbers in simulation. Default to 3.
  28. Returns:
  29. tuple(int): (x, y)
  30. """
  31. x = random_normal_distribution_int(area[0], area[2], n=n)
  32. y = random_normal_distribution_int(area[1], area[3], n=n)
  33. return x, y
  34. def random_rectangle_vector(vector, box, random_range=(0, 0, 0, 0), padding=15):
  35. """Place a vector in a box randomly.
  36. Args:
  37. vector: (x, y)
  38. box: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  39. random_range (tuple): Add a random_range to vector. (x_min, y_min, x_max, y_max).
  40. padding (int):
  41. Returns:
  42. tuple(int), tuple(int): start_point, end_point.
  43. """
  44. vector = np.array(vector) + random_rectangle_point(random_range)
  45. vector = np.round(vector).astype(np.int)
  46. half_vector = np.round(vector / 2).astype(np.int)
  47. box = np.array(box) + np.append(np.abs(half_vector) + padding, -np.abs(half_vector) - padding)
  48. center = random_rectangle_point(box)
  49. start_point = center - half_vector
  50. end_point = start_point + vector
  51. return tuple(start_point), tuple(end_point)
  52. def random_rectangle_vector_opted(
  53. vector, box, random_range=(0, 0, 0, 0), padding=15, whitelist_area=None, blacklist_area=None):
  54. """
  55. Place a vector in a box randomly.
  56. When emulator/game stuck, it treats a swipe as a click, clicking at the end of swipe path.
  57. To prevent this, random results need to be filtered.
  58. Args:
  59. vector: (x, y)
  60. box: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  61. random_range (tuple): Add a random_range to vector. (x_min, y_min, x_max, y_max).
  62. padding (int):
  63. whitelist_area: (list[tuple[int]]):
  64. A list of area that safe to click. Swipe path will end there.
  65. blacklist_area: (list[tuple[int]]):
  66. If none of the whitelist_area satisfies current vector, blacklist_area will be used.
  67. Delete random path that ends in any blacklist_area.
  68. Returns:
  69. tuple(int), tuple(int): start_point, end_point.
  70. """
  71. vector = np.array(vector) + random_rectangle_point(random_range)
  72. vector = np.round(vector).astype(np.int)
  73. half_vector = np.round(vector / 2).astype(np.int)
  74. box_pad = np.array(box) + np.append(np.abs(half_vector) + padding, -np.abs(half_vector) - padding)
  75. box_pad = area_offset(box_pad, half_vector)
  76. segment = int(np.linalg.norm(vector) // 70) + 1
  77. def in_blacklist(end):
  78. if not blacklist_area:
  79. return False
  80. for x in range(segment + 1):
  81. point = - vector * x / segment + end
  82. for area in blacklist_area:
  83. if point_in_area(point, area, threshold=0):
  84. return True
  85. return False
  86. if whitelist_area:
  87. for area in whitelist_area:
  88. area = area_limit(area, box_pad)
  89. if all([x > 0 for x in area_size(area)]):
  90. end_point = random_rectangle_point(area)
  91. for _ in range(10):
  92. if in_blacklist(end_point):
  93. continue
  94. return point_limit(end_point - vector, box), point_limit(end_point, box)
  95. for _ in range(100):
  96. end_point = random_rectangle_point(box_pad)
  97. if in_blacklist(end_point):
  98. continue
  99. return point_limit(end_point - vector, box), point_limit(end_point, box)
  100. end_point = random_rectangle_point(box_pad)
  101. return point_limit(end_point - vector, box), point_limit(end_point, box)
  102. def random_line_segments(p1, p2, n, random_range=(0, 0, 0, 0)):
  103. """Cut a line into multiple segments.
  104. Args:
  105. p1: (x, y).
  106. p2: (x, y).
  107. n: Number of slice.
  108. random_range: Add a random_range to points.
  109. Returns:
  110. list[tuple]: [(x0, y0), (x1, y1), (x2, y2)]
  111. """
  112. return [tuple((((n - index) * p1 + index * p2) / n).astype(int) + random_rectangle_point(random_range))
  113. for index in range(0, n + 1)]
  114. def ensure_time(second, n=3, precision=3):
  115. """Ensure to be time.
  116. Args:
  117. second (int, float, tuple): time, such as 10, (10, 30), '10, 30'
  118. n (int): The amount of numbers in simulation. Default to 5.
  119. precision (int): Decimals.
  120. Returns:
  121. float:
  122. """
  123. if isinstance(second, tuple):
  124. multiply = 10 ** precision
  125. result = random_normal_distribution_int(second[0] * multiply, second[1] * multiply, n) / multiply
  126. return round(result, precision)
  127. elif isinstance(second, str):
  128. if ',' in second:
  129. lower, upper = second.replace(' ', '').split(',')
  130. lower, upper = int(lower), int(upper)
  131. return ensure_time((lower, upper), n=n, precision=precision)
  132. if '-' in second:
  133. lower, upper = second.replace(' ', '').split('-')
  134. lower, upper = int(lower), int(upper)
  135. return ensure_time((lower, upper), n=n, precision=precision)
  136. else:
  137. return int(second)
  138. else:
  139. return second
  140. def ensure_int(*args):
  141. """
  142. Convert all elements to int.
  143. Return the same structure as nested objects.
  144. Args:
  145. *args:
  146. Returns:
  147. list:
  148. """
  149. def to_int(item):
  150. try:
  151. return int(item)
  152. except TypeError:
  153. result = [to_int(i) for i in item]
  154. if len(result) == 1:
  155. result = result[0]
  156. return result
  157. return to_int(args)
  158. def area_offset(area, offset):
  159. """
  160. Move an area.
  161. Args:
  162. area: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  163. offset: (x, y).
  164. Returns:
  165. tuple: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  166. """
  167. upper_left_x, upper_left_y, bottom_right_x, bottom_right_y = area
  168. x, y = offset
  169. return upper_left_x + x, upper_left_y + y, bottom_right_x + x, bottom_right_y + y
  170. def area_pad(area, pad=10):
  171. """
  172. Inner offset an area.
  173. Args:
  174. area: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  175. pad (int):
  176. Returns:
  177. tuple: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  178. """
  179. upper_left_x, upper_left_y, bottom_right_x, bottom_right_y = area
  180. return upper_left_x + pad, upper_left_y + pad, bottom_right_x - pad, bottom_right_y - pad
  181. def limit_in(x, lower, upper):
  182. """
  183. Limit x within range (lower, upper)
  184. Args:
  185. x:
  186. lower:
  187. upper:
  188. Returns:
  189. int, float:
  190. """
  191. return max(min(x, upper), lower)
  192. def area_limit(area1, area2):
  193. """
  194. Limit an area in another area.
  195. Args:
  196. area1: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  197. area2: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  198. Returns:
  199. tuple: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  200. """
  201. x_lower, y_lower, x_upper, y_upper = area2
  202. return (
  203. limit_in(area1[0], x_lower, x_upper),
  204. limit_in(area1[1], y_lower, y_upper),
  205. limit_in(area1[2], x_lower, x_upper),
  206. limit_in(area1[3], y_lower, y_upper),
  207. )
  208. def area_size(area):
  209. """
  210. Area size or shape.
  211. Args:
  212. area: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  213. Returns:
  214. tuple: (x, y).
  215. """
  216. return (
  217. max(area[2] - area[0], 0),
  218. max(area[3] - area[1], 0)
  219. )
  220. def point_limit(point, area):
  221. """
  222. Limit point in an area.
  223. Args:
  224. point: (x, y).
  225. area: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  226. Returns:
  227. tuple: (x, y).
  228. """
  229. return (
  230. limit_in(point[0], area[0], area[2]),
  231. limit_in(point[1], area[1], area[3])
  232. )
  233. def point_in_area(point, area, threshold=5):
  234. """
  235. Args:
  236. point: (x, y).
  237. area: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  238. threshold: int
  239. Returns:
  240. bool:
  241. """
  242. return area[0] - threshold < point[0] < area[2] + threshold and area[1] - threshold < point[1] < area[3] + threshold
  243. def area_in_area(area1, area2, threshold=5):
  244. """
  245. Args:
  246. area1: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  247. area2: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  248. threshold: int
  249. Returns:
  250. bool:
  251. """
  252. return area2[0] - threshold <= area1[0] \
  253. and area2[1] - threshold <= area1[1] \
  254. and area1[2] <= area2[2] + threshold \
  255. and area1[3] <= area2[3] + threshold
  256. def area_cross_area(area1, area2, threshold=5):
  257. """
  258. Args:
  259. area1: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  260. area2: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y).
  261. threshold: int
  262. Returns:
  263. bool:
  264. """
  265. # https://www.yiiven.cn/rect-is-intersection.html
  266. xa1, ya1, xa2, ya2 = area1
  267. xb1, yb1, xb2, yb2 = area2
  268. return abs(xb2 + xb1 - xa2 - xa1) <= xa2 - xa1 + xb2 - xb1 + threshold * 2 \
  269. and abs(yb2 + yb1 - ya2 - ya1) <= ya2 - ya1 + yb2 - yb1 + threshold * 2
  270. def float2str(n, decimal=3):
  271. """
  272. Args:
  273. n (float):
  274. decimal (int):
  275. Returns:
  276. str:
  277. """
  278. return str(round(n, decimal)).ljust(decimal + 2, "0")
  279. def point2str(x, y, length=4):
  280. """
  281. Args:
  282. x (int, float):
  283. y (int, float):
  284. length (int): Align length.
  285. Returns:
  286. str: String with numbers right aligned, such as '( 100, 80)'.
  287. """
  288. return '(%s, %s)' % (str(int(x)).rjust(length), str(int(y)).rjust(length))
  289. def col2name(col):
  290. """
  291. Convert a zero indexed column cell reference to a string.
  292. Args:
  293. col: The cell column. Int.
  294. Returns:
  295. Column style string.
  296. Examples:
  297. 0 -> A, 3 -> D, 35 -> AJ, -1 -> -A
  298. """
  299. col_neg = col < 0
  300. if col_neg:
  301. col_num = -col
  302. else:
  303. col_num = col + 1 # Change to 1-index.
  304. col_str = ''
  305. while col_num:
  306. # Set remainder from 1 .. 26
  307. remainder = col_num % 26
  308. if remainder == 0:
  309. remainder = 26
  310. # Convert the remainder to a character.
  311. col_letter = chr(remainder + 64)
  312. # Accumulate the column letters, right to left.
  313. col_str = col_letter + col_str
  314. # Get the next order of magnitude.
  315. col_num = int((col_num - 1) / 26)
  316. if col_neg:
  317. return '-' + col_str
  318. else:
  319. return col_str
  320. def name2col(col_str):
  321. """
  322. Convert a cell reference in A1 notation to a zero indexed row and column.
  323. Args:
  324. col_str: A1 style string.
  325. Returns:
  326. row, col: Zero indexed cell row and column indices.
  327. """
  328. # Convert base26 column string to number.
  329. expn = 0
  330. col = 0
  331. col_neg = col_str.startswith('-')
  332. col_str = col_str.strip('-').upper()
  333. for char in reversed(col_str):
  334. col += (ord(char) - 64) * (26 ** expn)
  335. expn += 1
  336. if col_neg:
  337. return -col
  338. else:
  339. return col - 1 # Convert 1-index to zero-index
  340. def node2location(node):
  341. """
  342. See location2node()
  343. Args:
  344. node (str): Example: 'E3'
  345. Returns:
  346. tuple[int]: Example: (4, 2)
  347. """
  348. res = REGEX_NODE.search(node)
  349. if res:
  350. x, y = res.group(1), res.group(2)
  351. y = int(y)
  352. if y > 0:
  353. y -= 1
  354. return name2col(x), y
  355. else:
  356. # Whatever
  357. return ord(node[0]) % 32 - 1, int(node[1:]) - 1
  358. def location2node(location):
  359. """
  360. Convert location tuple to an Excel-like cell.
  361. Accept negative values also.
  362. -2 -1 0 1 2 3
  363. -2 -B-2 -A-2 A-2 B-2 C-2 D-2
  364. -1 -B-1 -A-1 A-1 B-1 C-1 D-1
  365. 0 -B1 -A1 A1 B1 C1 D1
  366. 1 -B2 -A2 A2 B2 C2 D2
  367. 2 -B3 -A3 A3 B3 C3 D3
  368. 3 -B4 -A4 A4 B4 C4 D4
  369. # To generate the table above
  370. index = range(-2, 4)
  371. row = ' ' + ' '.join([str(i).rjust(4) for i in index])
  372. print(row)
  373. for y in index:
  374. row = str(y).rjust(2) + ' ' + ' '.join([location2node((x, y)).rjust(4) for x in index])
  375. print(row)
  376. def check(node):
  377. return point2str(*node2location(location2node(node)), length=2)
  378. row = ' ' + ' '.join([str(i).rjust(8) for i in index])
  379. print(row)
  380. for y in index:
  381. row = str(y).rjust(2) + ' ' + ' '.join([check((x, y)).rjust(4) for x in index])
  382. print(row)
  383. Args:
  384. location (tuple[int]):
  385. Returns:
  386. str:
  387. """
  388. x, y = location
  389. if y >= 0:
  390. y += 1
  391. return col2name(x) + str(y)
  392. def load_image(file, area=None):
  393. """
  394. Load an image like pillow and drop alpha channel.
  395. Args:
  396. file (str):
  397. area (tuple):
  398. Returns:
  399. np.ndarray:
  400. """
  401. image = Image.open(file)
  402. if area is not None:
  403. image = image.crop(area)
  404. image = np.array(image)
  405. channel = image.shape[2] if len(image.shape) > 2 else 1
  406. if channel > 3:
  407. image = image[:, :, :3].copy()
  408. return image
  409. def save_image(image, file):
  410. """
  411. Save an image like pillow.
  412. Args:
  413. image (np.ndarray):
  414. file (str):
  415. """
  416. # image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
  417. # cv2.imwrite(file, image)
  418. Image.fromarray(image).save(file)
  419. def crop(image, area, copy=True):
  420. """
  421. Crop image like pillow, when using opencv / numpy.
  422. Provides a black background if cropping outside of image.
  423. Args:
  424. image (np.ndarray):
  425. area:
  426. copy (bool):
  427. Returns:
  428. np.ndarray:
  429. """
  430. x1, y1, x2, y2 = map(int, map(round, area))
  431. h, w = image.shape[:2]
  432. border = np.maximum((0 - y1, y2 - h, 0 - x1, x2 - w), 0)
  433. x1, y1, x2, y2 = np.maximum((x1, y1, x2, y2), 0)
  434. image = image[y1:y2, x1:x2]
  435. if sum(border) > 0:
  436. image = cv2.copyMakeBorder(image, *border, borderType=cv2.BORDER_CONSTANT, value=(0, 0, 0))
  437. if copy:
  438. image = image.copy()
  439. return image
  440. def resize(image, size):
  441. """
  442. Resize image like pillow image.resize(), but implement in opencv.
  443. Pillow uses PIL.Image.NEAREST by default.
  444. Args:
  445. image (np.ndarray):
  446. size: (x, y)
  447. Returns:
  448. np.ndarray:
  449. """
  450. return cv2.resize(image, size, interpolation=cv2.INTER_NEAREST)
  451. def image_channel(image):
  452. """
  453. Args:
  454. image (np.ndarray):
  455. Returns:
  456. int: 0 for grayscale, 3 for RGB.
  457. """
  458. return image.shape[2] if len(image.shape) == 3 else 0
  459. def image_size(image):
  460. """
  461. Args:
  462. image (np.ndarray):
  463. Returns:
  464. int, int: width, height
  465. """
  466. shape = image.shape
  467. return shape[1], shape[0]
  468. def rgb2gray(image):
  469. """
  470. Args:
  471. image (np.ndarray): Shape (height, width, channel)
  472. Returns:
  473. np.ndarray: Shape (height, width)
  474. """
  475. r, g, b = cv2.split(image)
  476. return cv2.add(
  477. cv2.multiply(cv2.max(cv2.max(r, g), b), 0.5),
  478. cv2.multiply(cv2.min(cv2.min(r, g), b), 0.5)
  479. )
  480. def rgb2hsv(image):
  481. """
  482. Convert RGB color space to HSV color space.
  483. HSV is Hue Saturation Value.
  484. Args:
  485. image (np.ndarray): Shape (height, width, channel)
  486. Returns:
  487. np.ndarray: Hue (0~360), Saturation (0~100), Value (0~100).
  488. """
  489. image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV).astype(np.float)
  490. image *= (360 / 180, 100 / 255, 100 / 255)
  491. return image
  492. def rgb2yuv(image):
  493. """
  494. Convert RGB to YUV color space.
  495. Args:
  496. image (np.ndarray): Shape (height, width, channel)
  497. Returns:
  498. np.ndarray: Shape (height, width)
  499. """
  500. image = cv2.cvtColor(image, cv2.COLOR_RGB2YUV)
  501. return image
  502. def rgb2luma(image):
  503. """
  504. Convert RGB to the Y channel (Luminance) in YUV color space.
  505. Args:
  506. image (np.ndarray): Shape (height, width, channel)
  507. Returns:
  508. np.ndarray: Shape (height, width)
  509. """
  510. image = cv2.cvtColor(image, cv2.COLOR_RGB2YUV)
  511. luma, _, _ = cv2.split(image)
  512. return luma
  513. def get_color(image, area):
  514. """Calculate the average color of a particular area of the image.
  515. Args:
  516. image (np.ndarray): Screenshot.
  517. area (tuple): (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y)
  518. Returns:
  519. tuple: (r, g, b)
  520. """
  521. temp = crop(image, area, copy=False)
  522. color = cv2.mean(temp)
  523. return color[:3]
  524. def get_bbox(image, threshold=0):
  525. """
  526. A numpy implementation of the getbbox() in pillow.
  527. Args:
  528. image (np.ndarray): Screenshot.
  529. threshold (int): Color <= threshold will be considered black
  530. Returns:
  531. tuple: (upper_left_x, upper_left_y, bottom_right_x, bottom_right_y)
  532. """
  533. if image_channel(image) == 3:
  534. image = np.max(image, axis=2)
  535. x = np.where(np.max(image, axis=0) > threshold)[0]
  536. y = np.where(np.max(image, axis=1) > threshold)[0]
  537. return x[0], y[0], x[-1] + 1, y[-1] + 1
  538. def color_similarity(color1, color2):
  539. """
  540. Args:
  541. color1 (tuple): (r, g, b)
  542. color2 (tuple): (r, g, b)
  543. Returns:
  544. int:
  545. """
  546. diff = np.array(color1).astype(int) - np.array(color2).astype(int)
  547. diff = np.max(np.maximum(diff, 0)) - np.min(np.minimum(diff, 0))
  548. return diff
  549. def color_similar(color1, color2, threshold=10):
  550. """Consider two colors are similar, if tolerance lesser or equal threshold.
  551. Tolerance = Max(Positive(difference_rgb)) + Max(- Negative(difference_rgb))
  552. The same as the tolerance in Photoshop.
  553. Args:
  554. color1 (tuple): (r, g, b)
  555. color2 (tuple): (r, g, b)
  556. threshold (int): Default to 10.
  557. Returns:
  558. bool: True if two colors are similar.
  559. """
  560. # print(color1, color2)
  561. diff = np.array(color1).astype(int) - np.array(color2).astype(int)
  562. diff = np.max(np.maximum(diff, 0)) - np.min(np.minimum(diff, 0))
  563. return diff <= threshold
  564. def color_similar_1d(image, color, threshold=10):
  565. """
  566. Args:
  567. image (np.ndarray): 1D array.
  568. color: (r, g, b)
  569. threshold(int): Default to 10.
  570. Returns:
  571. np.ndarray: bool
  572. """
  573. diff = image.astype(int) - color
  574. diff = np.max(np.maximum(diff, 0), axis=1) - np.min(np.minimum(diff, 0), axis=1)
  575. return diff <= threshold
  576. def color_similarity_2d(image, color):
  577. """
  578. Args:
  579. image: 2D array.
  580. color: (r, g, b)
  581. Returns:
  582. np.ndarray: uint8
  583. """
  584. r, g, b = cv2.split(cv2.subtract(image, (*color, 0)))
  585. positive = cv2.max(cv2.max(r, g), b)
  586. r, g, b = cv2.split(cv2.subtract((*color, 0), image))
  587. negative = cv2.max(cv2.max(r, g), b)
  588. return cv2.subtract(255, cv2.add(positive, negative))
  589. def extract_letters(image, letter=(255, 255, 255), threshold=128):
  590. """Set letter color to black, set background color to white.
  591. Args:
  592. image: Shape (height, width, channel)
  593. letter (tuple): Letter RGB.
  594. threshold (int):
  595. Returns:
  596. np.ndarray: Shape (height, width)
  597. """
  598. r, g, b = cv2.split(cv2.subtract(image, (*letter, 0)))
  599. positive = cv2.max(cv2.max(r, g), b)
  600. r, g, b = cv2.split(cv2.subtract((*letter, 0), image))
  601. negative = cv2.max(cv2.max(r, g), b)
  602. return cv2.multiply(cv2.add(positive, negative), 255.0 / threshold)
  603. def extract_white_letters(image, threshold=128):
  604. """Set letter color to black, set background color to white.
  605. This function will discourage color pixels (Non-gray pixels)
  606. Args:
  607. image: Shape (height, width, channel)
  608. threshold (int):
  609. Returns:
  610. np.ndarray: Shape (height, width)
  611. """
  612. r, g, b = cv2.split(cv2.subtract((255, 255, 255, 0), image))
  613. minimum = cv2.min(cv2.min(r, g), b)
  614. maximum = cv2.max(cv2.max(r, g), b)
  615. return cv2.multiply(cv2.add(maximum, cv2.subtract(maximum, minimum)), 255.0 / threshold)
  616. def color_mapping(image, max_multiply=2):
  617. """
  618. Mapping color to 0-255.
  619. Minimum color to 0, maximum color to 255, multiply colors by 2 at max.
  620. Args:
  621. image (np.ndarray):
  622. max_multiply (int, float):
  623. Returns:
  624. np.ndarray:
  625. """
  626. image = image.astype(float)
  627. low, high = np.min(image), np.max(image)
  628. multiply = min(255 / (high - low), max_multiply)
  629. add = (255 - multiply * (low + high)) / 2
  630. image = cv2.add(cv2.multiply(image, multiply), add)
  631. image[image > 255] = 255
  632. image[image < 0] = 0
  633. return image.astype(np.uint8)
  634. def image_left_strip(image, threshold, length):
  635. """
  636. In `DAILY:200/200` strip `DAILY:` and leave `200/200`
  637. Args:
  638. image (np.ndarray): (height, width)
  639. threshold (int):
  640. 0-255
  641. The first column with brightness lower than this
  642. will be considered as left edge.
  643. length (int):
  644. Strip this length of image after the left edge
  645. Returns:
  646. np.ndarray:
  647. """
  648. brightness = np.mean(image, axis=0)
  649. match = np.where(brightness < threshold)[0]
  650. if len(match):
  651. left = match[0] + length
  652. total = image.shape[1]
  653. if left < total:
  654. image = image[:, left:]
  655. return image
  656. def red_overlay_transparency(color1, color2, red=247):
  657. """Calculate the transparency of red overlay.
  658. Args:
  659. color1: origin color.
  660. color2: changed color.
  661. red(int): red color 0-255. Default to 247.
  662. Returns:
  663. float: 0-1
  664. """
  665. return (color2[0] - color1[0]) / (red - color1[0])
  666. def color_bar_percentage(image, area, prev_color, reverse=False, starter=0, threshold=30):
  667. """
  668. Args:
  669. image:
  670. area:
  671. prev_color:
  672. reverse: True if bar goes from right to left.
  673. starter:
  674. threshold:
  675. Returns:
  676. float: 0 to 1.
  677. """
  678. image = crop(image, area)
  679. image = image[:, ::-1, :] if reverse else image
  680. length = image.shape[1]
  681. prev_index = starter
  682. for _ in range(1280):
  683. bar = color_similarity_2d(image, color=prev_color)
  684. index = np.where(np.any(bar > 255 - threshold, axis=0))[0]
  685. if not index.size:
  686. return prev_index / length
  687. else:
  688. index = index[-1]
  689. if index <= prev_index:
  690. return index / length
  691. prev_index = index
  692. prev_row = bar[:, prev_index] > 255 - threshold
  693. if not prev_row.size:
  694. return prev_index / length
  695. prev_color = np.mean(image[:, prev_index], axis=0)
  696. return 0.
  697. def load_module(moduleName :str, moduleFile :str):
  698. """
  699. 加载模块
  700. :param moduleName:
  701. :param moduleFile: 文件路径带py
  702. :return:
  703. """
  704. spec = importlib.util.spec_from_file_location(moduleName, moduleFile)
  705. module = importlib.util.module_from_spec(spec)
  706. spec.loader.exec_module(module)
  707. sys.modules[moduleName] = module
  708. return module
  709. def angle(p1, p2, p3):
  710. """计算三点形成的角度(单位:度)"""
  711. v1 = p2 - p1
  712. v2 = p3 - p2
  713. cos_angle = np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
  714. return np.degrees(np.arccos(np.clip(cos_angle, -1.0, 1.0))) # 限制范围以防止浮点错误
  715. def is_approx_rectangle(points, tolerance=30):
  716. """判断四个点是否近似于矩形
  717. :param points: 坐上开始,逆时针
  718. :param tolerance: 角度 不是弧度
  719. """
  720. if points.shape[0] != 4:
  721. return False
  722. # # 计算边长
  723. # distances = [distance(points[i], points[j]) for i in range(4) for j in range(i + 1, 4)]
  724. # distances.sort()
  725. # # 最小边和最大边
  726. # short_sides = distances[:4]
  727. # long_sides = distances[4:]
  728. # # 判断边长是否接近
  729. # if not (np.isclose(short_sides[0], short_sides[1], atol=tolerance) and
  730. # np.isclose(long_sides[0], long_sides[1], atol=tolerance)):
  731. # return False
  732. # 检查角度
  733. angles = [
  734. angle(points[0], points[1], points[2]),
  735. angle(points[1], points[2], points[3]),
  736. angle(points[2], points[3], points[0]),
  737. angle(points[3], points[0], points[1])
  738. ]
  739. # 判断角度是否接近90度
  740. return all(np.isclose(a, 90, atol=tolerance) for a in angles)