shuvom commited on
Commit
5f5d58c
1 Parent(s): c8dff01

Upload folder using huggingface_hub

Browse files
This view is limited to 50 files because it contains too many changes.   See raw diff
Files changed (50) hide show
  1. .gitattributes +49 -0
  2. OpenHathi_self_instruct-v1.0/.gitattributes +35 -0
  3. OpenHathi_self_instruct-v1.0/README.md +13 -0
  4. README.md +2 -8
  5. app.py +107 -0
  6. d063433d-244d-4bb8-9386-87a6208c3184.pdf +0 -0
  7. env/.gitignore +2 -0
  8. env/Lib/site-packages/Jinja2-3.1.2.dist-info/INSTALLER +1 -0
  9. env/Lib/site-packages/Jinja2-3.1.2.dist-info/LICENSE.rst +28 -0
  10. env/Lib/site-packages/Jinja2-3.1.2.dist-info/METADATA +113 -0
  11. env/Lib/site-packages/Jinja2-3.1.2.dist-info/RECORD +58 -0
  12. env/Lib/site-packages/Jinja2-3.1.2.dist-info/WHEEL +5 -0
  13. env/Lib/site-packages/Jinja2-3.1.2.dist-info/entry_points.txt +2 -0
  14. env/Lib/site-packages/Jinja2-3.1.2.dist-info/top_level.txt +1 -0
  15. env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/INSTALLER +1 -0
  16. env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/LICENSE.rst +28 -0
  17. env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/METADATA +93 -0
  18. env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/RECORD +14 -0
  19. env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/WHEEL +5 -0
  20. env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/top_level.txt +1 -0
  21. env/Lib/site-packages/PIL/BdfFontFile.py +122 -0
  22. env/Lib/site-packages/PIL/BlpImagePlugin.py +474 -0
  23. env/Lib/site-packages/PIL/BmpImagePlugin.py +471 -0
  24. env/Lib/site-packages/PIL/BufrStubImagePlugin.py +73 -0
  25. env/Lib/site-packages/PIL/ContainerIO.py +120 -0
  26. env/Lib/site-packages/PIL/CurImagePlugin.py +75 -0
  27. env/Lib/site-packages/PIL/DcxImagePlugin.py +79 -0
  28. env/Lib/site-packages/PIL/DdsImagePlugin.py +295 -0
  29. env/Lib/site-packages/PIL/EpsImagePlugin.py +480 -0
  30. env/Lib/site-packages/PIL/ExifTags.py +380 -0
  31. env/Lib/site-packages/PIL/FitsImagePlugin.py +73 -0
  32. env/Lib/site-packages/PIL/FliImagePlugin.py +171 -0
  33. env/Lib/site-packages/PIL/FontFile.py +110 -0
  34. env/Lib/site-packages/PIL/FpxImagePlugin.py +253 -0
  35. env/Lib/site-packages/PIL/FtexImagePlugin.py +113 -0
  36. env/Lib/site-packages/PIL/GbrImagePlugin.py +102 -0
  37. env/Lib/site-packages/PIL/GdImageFile.py +97 -0
  38. env/Lib/site-packages/PIL/GifImagePlugin.py +1060 -0
  39. env/Lib/site-packages/PIL/GimpGradientFile.py +137 -0
  40. env/Lib/site-packages/PIL/GimpPaletteFile.py +56 -0
  41. env/Lib/site-packages/PIL/GribStubImagePlugin.py +73 -0
  42. env/Lib/site-packages/PIL/Hdf5StubImagePlugin.py +73 -0
  43. env/Lib/site-packages/PIL/IcnsImagePlugin.py +399 -0
  44. env/Lib/site-packages/PIL/IcoImagePlugin.py +358 -0
  45. env/Lib/site-packages/PIL/ImImagePlugin.py +371 -0
  46. env/Lib/site-packages/PIL/Image.py +0 -0
  47. env/Lib/site-packages/PIL/ImageChops.py +303 -0
  48. env/Lib/site-packages/PIL/ImageCms.py +1009 -0
  49. env/Lib/site-packages/PIL/ImageColor.py +313 -0
  50. env/Lib/site-packages/PIL/ImageDraw.py +1062 -0
.gitattributes CHANGED
@@ -33,3 +33,52 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
33
  *.zip filter=lfs diff=lfs merge=lfs -text
34
  *.zst filter=lfs diff=lfs merge=lfs -text
35
  *tfevents* filter=lfs diff=lfs merge=lfs -text
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
33
  *.zip filter=lfs diff=lfs merge=lfs -text
34
  *.zst filter=lfs diff=lfs merge=lfs -text
35
  *tfevents* filter=lfs diff=lfs merge=lfs -text
36
+ env/Lib/site-packages/altair/vegalite/v5/schema/__pycache__/channels.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
37
+ env/Lib/site-packages/altair/vegalite/v5/schema/__pycache__/core.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
38
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda110.so filter=lfs diff=lfs merge=lfs -text
39
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda110_nocublaslt.so filter=lfs diff=lfs merge=lfs -text
40
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda111.so filter=lfs diff=lfs merge=lfs -text
41
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda111_nocublaslt.so filter=lfs diff=lfs merge=lfs -text
42
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda114.so filter=lfs diff=lfs merge=lfs -text
43
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda114_nocublaslt.so filter=lfs diff=lfs merge=lfs -text
44
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda115.so filter=lfs diff=lfs merge=lfs -text
45
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda115_nocublaslt.so filter=lfs diff=lfs merge=lfs -text
46
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda117.so filter=lfs diff=lfs merge=lfs -text
47
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda117_nocublaslt.so filter=lfs diff=lfs merge=lfs -text
48
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda118.so filter=lfs diff=lfs merge=lfs -text
49
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda118_nocublaslt.so filter=lfs diff=lfs merge=lfs -text
50
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda120.so filter=lfs diff=lfs merge=lfs -text
51
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda120_nocublaslt.so filter=lfs diff=lfs merge=lfs -text
52
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda121.so filter=lfs diff=lfs merge=lfs -text
53
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda121_nocublaslt.so filter=lfs diff=lfs merge=lfs -text
54
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda122.so filter=lfs diff=lfs merge=lfs -text
55
+ env/Lib/site-packages/bitsandbytes/libbitsandbytes_cuda122_nocublaslt.so filter=lfs diff=lfs merge=lfs -text
56
+ env/Lib/site-packages/gradio/templates/frontend/assets/Index-8767f96e.js.map filter=lfs diff=lfs merge=lfs -text
57
+ env/Lib/site-packages/numpy/core/_multiarray_umath.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
58
+ env/Lib/site-packages/numpy/core/_simd.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
59
+ env/Lib/site-packages/numpy.libs/libopenblas64__v0.3.23-293-gc2f4bdbb-gcc_10_3_0-2bde3a66a51006b2b53eb373ff767a3f.dll filter=lfs diff=lfs merge=lfs -text
60
+ env/Lib/site-packages/pandas/_libs/algos.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
61
+ env/Lib/site-packages/pandas/_libs/groupby.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
62
+ env/Lib/site-packages/pandas/_libs/hashtable.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
63
+ env/Lib/site-packages/pandas/_libs/interval.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
64
+ env/Lib/site-packages/pandas/_libs/join.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
65
+ env/Lib/site-packages/PIL/_imaging.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
66
+ env/Lib/site-packages/PIL/_imagingft.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
67
+ env/Lib/site-packages/pydantic_core/_pydantic_core.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
68
+ env/Lib/site-packages/sympy/polys/benchmarks/__pycache__/bench_solvers.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
69
+ env/Lib/site-packages/tokenizers/tokenizers.cp311-win_amd64.pyd filter=lfs diff=lfs merge=lfs -text
70
+ env/Lib/site-packages/torch/bin/fbgemm.dll filter=lfs diff=lfs merge=lfs -text
71
+ env/Lib/site-packages/torch/bin/protoc.exe filter=lfs diff=lfs merge=lfs -text
72
+ env/Lib/site-packages/torch/lib/dnnl.lib filter=lfs diff=lfs merge=lfs -text
73
+ env/Lib/site-packages/torch/lib/fbgemm.dll filter=lfs diff=lfs merge=lfs -text
74
+ env/Lib/site-packages/torch/lib/fbgemm.lib filter=lfs diff=lfs merge=lfs -text
75
+ env/Lib/site-packages/torch/lib/fmt.lib filter=lfs diff=lfs merge=lfs -text
76
+ env/Lib/site-packages/torch/lib/kineto.lib filter=lfs diff=lfs merge=lfs -text
77
+ env/Lib/site-packages/torch/lib/libiomp5md.dll filter=lfs diff=lfs merge=lfs -text
78
+ env/Lib/site-packages/torch/lib/libprotobuf-lite.lib filter=lfs diff=lfs merge=lfs -text
79
+ env/Lib/site-packages/torch/lib/libprotobuf.lib filter=lfs diff=lfs merge=lfs -text
80
+ env/Lib/site-packages/torch/lib/libprotoc.lib filter=lfs diff=lfs merge=lfs -text
81
+ env/Lib/site-packages/torch/lib/torch_cpu.dll filter=lfs diff=lfs merge=lfs -text
82
+ env/Lib/site-packages/torch/lib/torch_cpu.lib filter=lfs diff=lfs merge=lfs -text
83
+ env/Lib/site-packages/torch/lib/torch_python.dll filter=lfs diff=lfs merge=lfs -text
84
+ env/Lib/site-packages/torch/lib/XNNPACK.lib filter=lfs diff=lfs merge=lfs -text
OpenHathi_self_instruct-v1.0/.gitattributes ADDED
@@ -0,0 +1,35 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ *.7z filter=lfs diff=lfs merge=lfs -text
2
+ *.arrow filter=lfs diff=lfs merge=lfs -text
3
+ *.bin filter=lfs diff=lfs merge=lfs -text
4
+ *.bz2 filter=lfs diff=lfs merge=lfs -text
5
+ *.ckpt filter=lfs diff=lfs merge=lfs -text
6
+ *.ftz filter=lfs diff=lfs merge=lfs -text
7
+ *.gz filter=lfs diff=lfs merge=lfs -text
8
+ *.h5 filter=lfs diff=lfs merge=lfs -text
9
+ *.joblib filter=lfs diff=lfs merge=lfs -text
10
+ *.lfs.* filter=lfs diff=lfs merge=lfs -text
11
+ *.mlmodel filter=lfs diff=lfs merge=lfs -text
12
+ *.model filter=lfs diff=lfs merge=lfs -text
13
+ *.msgpack filter=lfs diff=lfs merge=lfs -text
14
+ *.npy filter=lfs diff=lfs merge=lfs -text
15
+ *.npz filter=lfs diff=lfs merge=lfs -text
16
+ *.onnx filter=lfs diff=lfs merge=lfs -text
17
+ *.ot filter=lfs diff=lfs merge=lfs -text
18
+ *.parquet filter=lfs diff=lfs merge=lfs -text
19
+ *.pb filter=lfs diff=lfs merge=lfs -text
20
+ *.pickle filter=lfs diff=lfs merge=lfs -text
21
+ *.pkl filter=lfs diff=lfs merge=lfs -text
22
+ *.pt filter=lfs diff=lfs merge=lfs -text
23
+ *.pth filter=lfs diff=lfs merge=lfs -text
24
+ *.rar filter=lfs diff=lfs merge=lfs -text
25
+ *.safetensors filter=lfs diff=lfs merge=lfs -text
26
+ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
27
+ *.tar.* filter=lfs diff=lfs merge=lfs -text
28
+ *.tar filter=lfs diff=lfs merge=lfs -text
29
+ *.tflite filter=lfs diff=lfs merge=lfs -text
30
+ *.tgz filter=lfs diff=lfs merge=lfs -text
31
+ *.wasm filter=lfs diff=lfs merge=lfs -text
32
+ *.xz filter=lfs diff=lfs merge=lfs -text
33
+ *.zip filter=lfs diff=lfs merge=lfs -text
34
+ *.zst filter=lfs diff=lfs merge=lfs -text
35
+ *tfevents* filter=lfs diff=lfs merge=lfs -text
OpenHathi_self_instruct-v1.0/README.md ADDED
@@ -0,0 +1,13 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ---
2
+ title: OpenHathi Self Instruct-v1.0
3
+ emoji: 👀
4
+ colorFrom: yellow
5
+ colorTo: yellow
6
+ sdk: gradio
7
+ sdk_version: 4.12.0
8
+ app_file: app.py
9
+ pinned: false
10
+ license: llama2
11
+ ---
12
+
13
+ Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
README.md CHANGED
@@ -1,12 +1,6 @@
1
  ---
2
- title: OpenHathi SI V0.1
3
- emoji: 🌍
4
- colorFrom: green
5
- colorTo: gray
6
  sdk: gradio
7
  sdk_version: 4.12.0
8
- app_file: app.py
9
- pinned: false
10
  ---
11
-
12
- Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
 
1
  ---
2
+ title: OpenHathi-SI-v0.1
3
+ app_file: app.py
 
 
4
  sdk: gradio
5
  sdk_version: 4.12.0
 
 
6
  ---
 
 
app.py ADDED
@@ -0,0 +1,107 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import torch
2
+ from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer, TextStreamer
3
+ from threading import Thread
4
+ import gradio as gr
5
+ from peft import PeftModel
6
+
7
+ model_name_or_path = "sarvamai/OpenHathi-7B-Hi-v0.1-Base"
8
+ peft_model_id = "shuvom/OpenHathi-7B-FT-v0.1_SI"
9
+ model = AutoModelForCausalLM.from_pretrained(model_name_or_path, load_in_4bit=True, device_map="auto")
10
+
11
+ # tokenizer.chat_template = chat_template
12
+ tokenizer = AutoTokenizer.from_pretrained(peft_model_id)
13
+ # make embedding resizing configurable?
14
+ model.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=8)
15
+
16
+ model = PeftModel.from_pretrained(model, peft_model_id)
17
+
18
+ class ChatCompletion:
19
+ def __init__(self, model, tokenizer, system_prompt=None):
20
+ self.model = model
21
+ self.tokenizer = tokenizer
22
+ self.streamer = TextIteratorStreamer(self.tokenizer, skip_prompt=True)
23
+ self.print_streamer = TextStreamer(self.tokenizer, skip_prompt=True)
24
+ # set the model in inference mode
25
+ self.model.eval()
26
+ self.system_prompt = system_prompt
27
+
28
+ def get_completion(self, prompt, system_prompt=None, message_history=None, max_new_tokens=512, temperature=0.0):
29
+ if temperature < 1e-2:
30
+ temperature = 1e-2
31
+ messages = []
32
+ if message_history is not None:
33
+ messages.extend(message_history)
34
+ elif system_prompt or self.system_prompt:
35
+ system_prompt = system_prompt or self.system_prompt
36
+ messages.append({"role": "system", "content":system_prompt})
37
+ messages.append({"role": "user", "content": prompt})
38
+ chat_prompt = self.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
39
+
40
+ inputs = self.tokenizer(chat_prompt, return_tensors="pt", add_special_tokens=False)
41
+ # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way.
42
+ generation_kwargs = dict(max_new_tokens=max_new_tokens,
43
+ temperature=temperature,
44
+ top_p=0.95,
45
+ do_sample=True,
46
+ eos_token_id=tokenizer.eos_token_id,
47
+ repetition_penalty=1.2
48
+ )
49
+ generated_text = self.model.generate(**inputs, streamer=self.print_streamer, **generation_kwargs)
50
+ return generated_text
51
+
52
+ def get_chat_completion(self, message, history):
53
+ messages = []
54
+ if self.system_prompt:
55
+ messages.append({"role": "system", "content":self.system_prompt})
56
+ for user_message, assistant_message in history:
57
+ messages.append({"role": "user", "content": user_message})
58
+ messages.append({"role": "system", "content": assistant_message})
59
+ messages.append({"role": "user", "content": message})
60
+ chat_prompt = self.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
61
+
62
+ inputs = self.tokenizer(chat_prompt, return_tensors="pt")
63
+ # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way.
64
+ generation_kwargs = dict(inputs,
65
+ streamer=self.streamer,
66
+ max_new_tokens=2048,
67
+ temperature=0.2,
68
+ top_p=0.95,
69
+ eos_token_id=tokenizer.eos_token_id,
70
+ do_sample=True,
71
+ repetition_penalty=1.2,
72
+ )
73
+ thread = Thread(target=self.model.generate, kwargs=generation_kwargs)
74
+ thread.start()
75
+ generated_text = ""
76
+ for new_text in self.streamer:
77
+ generated_text += new_text.replace(self.tokenizer.eos_token, "")
78
+ yield generated_text
79
+ thread.join()
80
+ return generated_text
81
+
82
+ def get_completion_without_streaming(self, prompt, system_prompt=None, message_history=None, max_new_tokens=512, temperature=0.0):
83
+ if temperature < 1e-2:
84
+ temperature = 1e-2
85
+ messages = []
86
+ if message_history is not None:
87
+ messages.extend(message_history)
88
+ elif system_prompt or self.system_prompt:
89
+ system_prompt = system_prompt or self.system_prompt
90
+ messages.append({"role": "system", "content":system_prompt})
91
+ messages.append({"role": "user", "content": prompt})
92
+ chat_prompt = self.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
93
+
94
+ inputs = self.tokenizer(chat_prompt, return_tensors="pt", add_special_tokens=False)
95
+ # Run the generation in a separate thread, so that we can fetch the generated text in a non-blocking way.
96
+ generation_kwargs = dict(max_new_tokens=max_new_tokens,
97
+ temperature=temperature,
98
+ top_p=0.95,
99
+ do_sample=True,
100
+ repetition_penalty=1.1)
101
+ outputs = self.model.generate(**inputs, **generation_kwargs)
102
+ generated_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
103
+ return generated_text
104
+
105
+ text_generator = ChatCompletion(model, tokenizer, system_prompt="You are a native Hindi speaker who can converse at expert level in both Hindi and colloquial Hinglish.")
106
+
107
+ gr.ChatInterface(text_generator.get_chat_completion).queue().launch(debug=True)
d063433d-244d-4bb8-9386-87a6208c3184.pdf ADDED
Binary file (682 kB). View file
 
env/.gitignore ADDED
@@ -0,0 +1,2 @@
 
 
 
1
+ # created by virtualenv automatically
2
+ *
env/Lib/site-packages/Jinja2-3.1.2.dist-info/INSTALLER ADDED
@@ -0,0 +1 @@
 
 
1
+ pip
env/Lib/site-packages/Jinja2-3.1.2.dist-info/LICENSE.rst ADDED
@@ -0,0 +1,28 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ Copyright 2007 Pallets
2
+
3
+ Redistribution and use in source and binary forms, with or without
4
+ modification, are permitted provided that the following conditions are
5
+ met:
6
+
7
+ 1. Redistributions of source code must retain the above copyright
8
+ notice, this list of conditions and the following disclaimer.
9
+
10
+ 2. Redistributions in binary form must reproduce the above copyright
11
+ notice, this list of conditions and the following disclaimer in the
12
+ documentation and/or other materials provided with the distribution.
13
+
14
+ 3. Neither the name of the copyright holder nor the names of its
15
+ contributors may be used to endorse or promote products derived from
16
+ this software without specific prior written permission.
17
+
18
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
21
+ PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22
+ HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
24
+ TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
25
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
27
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
env/Lib/site-packages/Jinja2-3.1.2.dist-info/METADATA ADDED
@@ -0,0 +1,113 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ Metadata-Version: 2.1
2
+ Name: Jinja2
3
+ Version: 3.1.2
4
+ Summary: A very fast and expressive template engine.
5
+ Home-page: https://palletsprojects.com/p/jinja/
6
+ Author: Armin Ronacher
7
+ Author-email: [email protected]
8
+ Maintainer: Pallets
9
+ Maintainer-email: [email protected]
10
+ License: BSD-3-Clause
11
+ Project-URL: Donate, https://palletsprojects.com/donate
12
+ Project-URL: Documentation, https://jinja.palletsprojects.com/
13
+ Project-URL: Changes, https://jinja.palletsprojects.com/changes/
14
+ Project-URL: Source Code, https://github.com/pallets/jinja/
15
+ Project-URL: Issue Tracker, https://github.com/pallets/jinja/issues/
16
+ Project-URL: Twitter, https://twitter.com/PalletsTeam
17
+ Project-URL: Chat, https://discord.gg/pallets
18
+ Platform: UNKNOWN
19
+ Classifier: Development Status :: 5 - Production/Stable
20
+ Classifier: Environment :: Web Environment
21
+ Classifier: Intended Audience :: Developers
22
+ Classifier: License :: OSI Approved :: BSD License
23
+ Classifier: Operating System :: OS Independent
24
+ Classifier: Programming Language :: Python
25
+ Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
26
+ Classifier: Topic :: Text Processing :: Markup :: HTML
27
+ Requires-Python: >=3.7
28
+ Description-Content-Type: text/x-rst
29
+ License-File: LICENSE.rst
30
+ Requires-Dist: MarkupSafe (>=2.0)
31
+ Provides-Extra: i18n
32
+ Requires-Dist: Babel (>=2.7) ; extra == 'i18n'
33
+
34
+ Jinja
35
+ =====
36
+
37
+ Jinja is a fast, expressive, extensible templating engine. Special
38
+ placeholders in the template allow writing code similar to Python
39
+ syntax. Then the template is passed data to render the final document.
40
+
41
+ It includes:
42
+
43
+ - Template inheritance and inclusion.
44
+ - Define and import macros within templates.
45
+ - HTML templates can use autoescaping to prevent XSS from untrusted
46
+ user input.
47
+ - A sandboxed environment can safely render untrusted templates.
48
+ - AsyncIO support for generating templates and calling async
49
+ functions.
50
+ - I18N support with Babel.
51
+ - Templates are compiled to optimized Python code just-in-time and
52
+ cached, or can be compiled ahead-of-time.
53
+ - Exceptions point to the correct line in templates to make debugging
54
+ easier.
55
+ - Extensible filters, tests, functions, and even syntax.
56
+
57
+ Jinja's philosophy is that while application logic belongs in Python if
58
+ possible, it shouldn't make the template designer's job difficult by
59
+ restricting functionality too much.
60
+
61
+
62
+ Installing
63
+ ----------
64
+
65
+ Install and update using `pip`_:
66
+
67
+ .. code-block:: text
68
+
69
+ $ pip install -U Jinja2
70
+
71
+ .. _pip: https://pip.pypa.io/en/stable/getting-started/
72
+
73
+
74
+ In A Nutshell
75
+ -------------
76
+
77
+ .. code-block:: jinja
78
+
79
+ {% extends "base.html" %}
80
+ {% block title %}Members{% endblock %}
81
+ {% block content %}
82
+ <ul>
83
+ {% for user in users %}
84
+ <li><a href="{{ user.url }}">{{ user.username }}</a></li>
85
+ {% endfor %}
86
+ </ul>
87
+ {% endblock %}
88
+
89
+
90
+ Donate
91
+ ------
92
+
93
+ The Pallets organization develops and supports Jinja and other popular
94
+ packages. In order to grow the community of contributors and users, and
95
+ allow the maintainers to devote more time to the projects, `please
96
+ donate today`_.
97
+
98
+ .. _please donate today: https://palletsprojects.com/donate
99
+
100
+
101
+ Links
102
+ -----
103
+
104
+ - Documentation: https://jinja.palletsprojects.com/
105
+ - Changes: https://jinja.palletsprojects.com/changes/
106
+ - PyPI Releases: https://pypi.org/project/Jinja2/
107
+ - Source Code: https://github.com/pallets/jinja/
108
+ - Issue Tracker: https://github.com/pallets/jinja/issues/
109
+ - Website: https://palletsprojects.com/p/jinja/
110
+ - Twitter: https://twitter.com/PalletsTeam
111
+ - Chat: https://discord.gg/pallets
112
+
113
+
env/Lib/site-packages/Jinja2-3.1.2.dist-info/RECORD ADDED
@@ -0,0 +1,58 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ Jinja2-3.1.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
2
+ Jinja2-3.1.2.dist-info/LICENSE.rst,sha256=O0nc7kEF6ze6wQ-vG-JgQI_oXSUrjp3y4JefweCUQ3s,1475
3
+ Jinja2-3.1.2.dist-info/METADATA,sha256=PZ6v2SIidMNixR7MRUX9f7ZWsPwtXanknqiZUmRbh4U,3539
4
+ Jinja2-3.1.2.dist-info/RECORD,,
5
+ Jinja2-3.1.2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
6
+ Jinja2-3.1.2.dist-info/entry_points.txt,sha256=zRd62fbqIyfUpsRtU7EVIFyiu1tPwfgO7EvPErnxgTE,59
7
+ Jinja2-3.1.2.dist-info/top_level.txt,sha256=PkeVWtLb3-CqjWi1fO29OCbj55EhX_chhKrCdrVe_zs,7
8
+ jinja2/__init__.py,sha256=8vGduD8ytwgD6GDSqpYc2m3aU-T7PKOAddvVXgGr_Fs,1927
9
+ jinja2/__pycache__/__init__.cpython-311.pyc,,
10
+ jinja2/__pycache__/_identifier.cpython-311.pyc,,
11
+ jinja2/__pycache__/async_utils.cpython-311.pyc,,
12
+ jinja2/__pycache__/bccache.cpython-311.pyc,,
13
+ jinja2/__pycache__/compiler.cpython-311.pyc,,
14
+ jinja2/__pycache__/constants.cpython-311.pyc,,
15
+ jinja2/__pycache__/debug.cpython-311.pyc,,
16
+ jinja2/__pycache__/defaults.cpython-311.pyc,,
17
+ jinja2/__pycache__/environment.cpython-311.pyc,,
18
+ jinja2/__pycache__/exceptions.cpython-311.pyc,,
19
+ jinja2/__pycache__/ext.cpython-311.pyc,,
20
+ jinja2/__pycache__/filters.cpython-311.pyc,,
21
+ jinja2/__pycache__/idtracking.cpython-311.pyc,,
22
+ jinja2/__pycache__/lexer.cpython-311.pyc,,
23
+ jinja2/__pycache__/loaders.cpython-311.pyc,,
24
+ jinja2/__pycache__/meta.cpython-311.pyc,,
25
+ jinja2/__pycache__/nativetypes.cpython-311.pyc,,
26
+ jinja2/__pycache__/nodes.cpython-311.pyc,,
27
+ jinja2/__pycache__/optimizer.cpython-311.pyc,,
28
+ jinja2/__pycache__/parser.cpython-311.pyc,,
29
+ jinja2/__pycache__/runtime.cpython-311.pyc,,
30
+ jinja2/__pycache__/sandbox.cpython-311.pyc,,
31
+ jinja2/__pycache__/tests.cpython-311.pyc,,
32
+ jinja2/__pycache__/utils.cpython-311.pyc,,
33
+ jinja2/__pycache__/visitor.cpython-311.pyc,,
34
+ jinja2/_identifier.py,sha256=_zYctNKzRqlk_murTNlzrju1FFJL7Va_Ijqqd7ii2lU,1958
35
+ jinja2/async_utils.py,sha256=dHlbTeaxFPtAOQEYOGYh_PHcDT0rsDaUJAFDl_0XtTg,2472
36
+ jinja2/bccache.py,sha256=mhz5xtLxCcHRAa56azOhphIAe19u1we0ojifNMClDio,14061
37
+ jinja2/compiler.py,sha256=Gs-N8ThJ7OWK4-reKoO8Wh1ZXz95MVphBKNVf75qBr8,72172
38
+ jinja2/constants.py,sha256=GMoFydBF_kdpaRKPoM5cl5MviquVRLVyZtfp5-16jg0,1433
39
+ jinja2/debug.py,sha256=iWJ432RadxJNnaMOPrjIDInz50UEgni3_HKuFXi2vuQ,6299
40
+ jinja2/defaults.py,sha256=boBcSw78h-lp20YbaXSJsqkAI2uN_mD_TtCydpeq5wU,1267
41
+ jinja2/environment.py,sha256=6uHIcc7ZblqOMdx_uYNKqRnnwAF0_nzbyeMP9FFtuh4,61349
42
+ jinja2/exceptions.py,sha256=ioHeHrWwCWNaXX1inHmHVblvc4haO7AXsjCp3GfWvx0,5071
43
+ jinja2/ext.py,sha256=ivr3P7LKbddiXDVez20EflcO3q2aHQwz9P_PgWGHVqE,31502
44
+ jinja2/filters.py,sha256=9js1V-h2RlyW90IhLiBGLM2U-k6SCy2F4BUUMgB3K9Q,53509
45
+ jinja2/idtracking.py,sha256=GfNmadir4oDALVxzn3DL9YInhJDr69ebXeA2ygfuCGA,10704
46
+ jinja2/lexer.py,sha256=DW2nX9zk-6MWp65YR2bqqj0xqCvLtD-u9NWT8AnFRxQ,29726
47
+ jinja2/loaders.py,sha256=BfptfvTVpClUd-leMkHczdyPNYFzp_n7PKOJ98iyHOg,23207
48
+ jinja2/meta.py,sha256=GNPEvifmSaU3CMxlbheBOZjeZ277HThOPUTf1RkppKQ,4396
49
+ jinja2/nativetypes.py,sha256=DXgORDPRmVWgy034H0xL8eF7qYoK3DrMxs-935d0Fzk,4226
50
+ jinja2/nodes.py,sha256=i34GPRAZexXMT6bwuf5SEyvdmS-bRCy9KMjwN5O6pjk,34550
51
+ jinja2/optimizer.py,sha256=tHkMwXxfZkbfA1KmLcqmBMSaz7RLIvvItrJcPoXTyD8,1650
52
+ jinja2/parser.py,sha256=nHd-DFHbiygvfaPtm9rcQXJChZG7DPsWfiEsqfwKerY,39595
53
+ jinja2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
54
+ jinja2/runtime.py,sha256=5CmD5BjbEJxSiDNTFBeKCaq8qU4aYD2v6q2EluyExms,33476
55
+ jinja2/sandbox.py,sha256=Y0xZeXQnH6EX5VjaV2YixESxoepnRbW_3UeQosaBU3M,14584
56
+ jinja2/tests.py,sha256=Am5Z6Lmfr2XaH_npIfJJ8MdXtWsbLjMULZJulTAj30E,5905
57
+ jinja2/utils.py,sha256=u9jXESxGn8ATZNVolwmkjUVu4SA-tLgV0W7PcSfPfdQ,23965
58
+ jinja2/visitor.py,sha256=MH14C6yq24G_KVtWzjwaI7Wg14PCJIYlWW1kpkxYak0,3568
env/Lib/site-packages/Jinja2-3.1.2.dist-info/WHEEL ADDED
@@ -0,0 +1,5 @@
 
 
 
 
 
 
1
+ Wheel-Version: 1.0
2
+ Generator: bdist_wheel (0.37.1)
3
+ Root-Is-Purelib: true
4
+ Tag: py3-none-any
5
+
env/Lib/site-packages/Jinja2-3.1.2.dist-info/entry_points.txt ADDED
@@ -0,0 +1,2 @@
 
 
 
1
+ [babel.extractors]
2
+ jinja2 = jinja2.ext:babel_extract[i18n]
env/Lib/site-packages/Jinja2-3.1.2.dist-info/top_level.txt ADDED
@@ -0,0 +1 @@
 
 
1
+ jinja2
env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/INSTALLER ADDED
@@ -0,0 +1 @@
 
 
1
+ pip
env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/LICENSE.rst ADDED
@@ -0,0 +1,28 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ Copyright 2010 Pallets
2
+
3
+ Redistribution and use in source and binary forms, with or without
4
+ modification, are permitted provided that the following conditions are
5
+ met:
6
+
7
+ 1. Redistributions of source code must retain the above copyright
8
+ notice, this list of conditions and the following disclaimer.
9
+
10
+ 2. Redistributions in binary form must reproduce the above copyright
11
+ notice, this list of conditions and the following disclaimer in the
12
+ documentation and/or other materials provided with the distribution.
13
+
14
+ 3. Neither the name of the copyright holder nor the names of its
15
+ contributors may be used to endorse or promote products derived from
16
+ this software without specific prior written permission.
17
+
18
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
21
+ PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22
+ HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23
+ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
24
+ TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
25
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
27
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/METADATA ADDED
@@ -0,0 +1,93 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ Metadata-Version: 2.1
2
+ Name: MarkupSafe
3
+ Version: 2.1.3
4
+ Summary: Safely add untrusted strings to HTML/XML markup.
5
+ Home-page: https://palletsprojects.com/p/markupsafe/
6
+ Maintainer: Pallets
7
+ Maintainer-email: [email protected]
8
+ License: BSD-3-Clause
9
+ Project-URL: Donate, https://palletsprojects.com/donate
10
+ Project-URL: Documentation, https://markupsafe.palletsprojects.com/
11
+ Project-URL: Changes, https://markupsafe.palletsprojects.com/changes/
12
+ Project-URL: Source Code, https://github.com/pallets/markupsafe/
13
+ Project-URL: Issue Tracker, https://github.com/pallets/markupsafe/issues/
14
+ Project-URL: Chat, https://discord.gg/pallets
15
+ Classifier: Development Status :: 5 - Production/Stable
16
+ Classifier: Environment :: Web Environment
17
+ Classifier: Intended Audience :: Developers
18
+ Classifier: License :: OSI Approved :: BSD License
19
+ Classifier: Operating System :: OS Independent
20
+ Classifier: Programming Language :: Python
21
+ Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
22
+ Classifier: Topic :: Text Processing :: Markup :: HTML
23
+ Requires-Python: >=3.7
24
+ Description-Content-Type: text/x-rst
25
+ License-File: LICENSE.rst
26
+
27
+ MarkupSafe
28
+ ==========
29
+
30
+ MarkupSafe implements a text object that escapes characters so it is
31
+ safe to use in HTML and XML. Characters that have special meanings are
32
+ replaced so that they display as the actual characters. This mitigates
33
+ injection attacks, meaning untrusted user input can safely be displayed
34
+ on a page.
35
+
36
+
37
+ Installing
38
+ ----------
39
+
40
+ Install and update using `pip`_:
41
+
42
+ .. code-block:: text
43
+
44
+ pip install -U MarkupSafe
45
+
46
+ .. _pip: https://pip.pypa.io/en/stable/getting-started/
47
+
48
+
49
+ Examples
50
+ --------
51
+
52
+ .. code-block:: pycon
53
+
54
+ >>> from markupsafe import Markup, escape
55
+
56
+ >>> # escape replaces special characters and wraps in Markup
57
+ >>> escape("<script>alert(document.cookie);</script>")
58
+ Markup('&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
59
+
60
+ >>> # wrap in Markup to mark text "safe" and prevent escaping
61
+ >>> Markup("<strong>Hello</strong>")
62
+ Markup('<strong>hello</strong>')
63
+
64
+ >>> escape(Markup("<strong>Hello</strong>"))
65
+ Markup('<strong>hello</strong>')
66
+
67
+ >>> # Markup is a str subclass
68
+ >>> # methods and operators escape their arguments
69
+ >>> template = Markup("Hello <em>{name}</em>")
70
+ >>> template.format(name='"World"')
71
+ Markup('Hello <em>&#34;World&#34;</em>')
72
+
73
+
74
+ Donate
75
+ ------
76
+
77
+ The Pallets organization develops and supports MarkupSafe and other
78
+ popular packages. In order to grow the community of contributors and
79
+ users, and allow the maintainers to devote more time to the projects,
80
+ `please donate today`_.
81
+
82
+ .. _please donate today: https://palletsprojects.com/donate
83
+
84
+
85
+ Links
86
+ -----
87
+
88
+ - Documentation: https://markupsafe.palletsprojects.com/
89
+ - Changes: https://markupsafe.palletsprojects.com/changes/
90
+ - PyPI Releases: https://pypi.org/project/MarkupSafe/
91
+ - Source Code: https://github.com/pallets/markupsafe/
92
+ - Issue Tracker: https://github.com/pallets/markupsafe/issues/
93
+ - Chat: https://discord.gg/pallets
env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/RECORD ADDED
@@ -0,0 +1,14 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ MarkupSafe-2.1.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
2
+ MarkupSafe-2.1.3.dist-info/LICENSE.rst,sha256=RjHsDbX9kKVH4zaBcmTGeYIUM4FG-KyUtKV_lu6MnsQ,1503
3
+ MarkupSafe-2.1.3.dist-info/METADATA,sha256=5gU_TQw6eHpTaqkI6SPeZje6KTPlJPAV82uNiL3naKE,3096
4
+ MarkupSafe-2.1.3.dist-info/RECORD,,
5
+ MarkupSafe-2.1.3.dist-info/WHEEL,sha256=9wvhO-5NhjjD8YmmxAvXTPQXMDOZ50W5vklzeoqFtkM,102
6
+ MarkupSafe-2.1.3.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11
7
+ markupsafe/__init__.py,sha256=GsRaSTjrhvg6c88PnPJNqm4MafU_mFatfXz4-h80-Qc,10642
8
+ markupsafe/__pycache__/__init__.cpython-311.pyc,,
9
+ markupsafe/__pycache__/_native.cpython-311.pyc,,
10
+ markupsafe/_native.py,sha256=_Q7UsXCOvgdonCgqG3l5asANI6eo50EKnDM-mlwEC5M,1776
11
+ markupsafe/_speedups.c,sha256=n3jzzaJwXcoN8nTFyA53f3vSqsWK2vujI-v6QYifjhQ,7403
12
+ markupsafe/_speedups.cp311-win_amd64.pyd,sha256=TEUZdBQBxs061oYZQP2cGGlADVOAdHridgTeE6XQxTE,15872
13
+ markupsafe/_speedups.pyi,sha256=f5QtwIOP0eLrxh2v5p6SmaYmlcHIGIfmz0DovaqL0OU,238
14
+ markupsafe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/WHEEL ADDED
@@ -0,0 +1,5 @@
 
 
 
 
 
 
1
+ Wheel-Version: 1.0
2
+ Generator: bdist_wheel (0.40.0)
3
+ Root-Is-Purelib: false
4
+ Tag: cp311-cp311-win_amd64
5
+
env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/top_level.txt ADDED
@@ -0,0 +1 @@
 
 
1
+ markupsafe
env/Lib/site-packages/PIL/BdfFontFile.py ADDED
@@ -0,0 +1,122 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library
3
+ # $Id$
4
+ #
5
+ # bitmap distribution font (bdf) file parser
6
+ #
7
+ # history:
8
+ # 1996-05-16 fl created (as bdf2pil)
9
+ # 1997-08-25 fl converted to FontFile driver
10
+ # 2001-05-25 fl removed bogus __init__ call
11
+ # 2002-11-20 fl robustification (from Kevin Cazabon, Dmitry Vasiliev)
12
+ # 2003-04-22 fl more robustification (from Graham Dumpleton)
13
+ #
14
+ # Copyright (c) 1997-2003 by Secret Labs AB.
15
+ # Copyright (c) 1997-2003 by Fredrik Lundh.
16
+ #
17
+ # See the README file for information on usage and redistribution.
18
+ #
19
+
20
+ """
21
+ Parse X Bitmap Distribution Format (BDF)
22
+ """
23
+
24
+
25
+ from . import FontFile, Image
26
+
27
+ bdf_slant = {
28
+ "R": "Roman",
29
+ "I": "Italic",
30
+ "O": "Oblique",
31
+ "RI": "Reverse Italic",
32
+ "RO": "Reverse Oblique",
33
+ "OT": "Other",
34
+ }
35
+
36
+ bdf_spacing = {"P": "Proportional", "M": "Monospaced", "C": "Cell"}
37
+
38
+
39
+ def bdf_char(f):
40
+ # skip to STARTCHAR
41
+ while True:
42
+ s = f.readline()
43
+ if not s:
44
+ return None
45
+ if s[:9] == b"STARTCHAR":
46
+ break
47
+ id = s[9:].strip().decode("ascii")
48
+
49
+ # load symbol properties
50
+ props = {}
51
+ while True:
52
+ s = f.readline()
53
+ if not s or s[:6] == b"BITMAP":
54
+ break
55
+ i = s.find(b" ")
56
+ props[s[:i].decode("ascii")] = s[i + 1 : -1].decode("ascii")
57
+
58
+ # load bitmap
59
+ bitmap = []
60
+ while True:
61
+ s = f.readline()
62
+ if not s or s[:7] == b"ENDCHAR":
63
+ break
64
+ bitmap.append(s[:-1])
65
+ bitmap = b"".join(bitmap)
66
+
67
+ # The word BBX
68
+ # followed by the width in x (BBw), height in y (BBh),
69
+ # and x and y displacement (BBxoff0, BByoff0)
70
+ # of the lower left corner from the origin of the character.
71
+ width, height, x_disp, y_disp = (int(p) for p in props["BBX"].split())
72
+
73
+ # The word DWIDTH
74
+ # followed by the width in x and y of the character in device pixels.
75
+ dwx, dwy = (int(p) for p in props["DWIDTH"].split())
76
+
77
+ bbox = (
78
+ (dwx, dwy),
79
+ (x_disp, -y_disp - height, width + x_disp, -y_disp),
80
+ (0, 0, width, height),
81
+ )
82
+
83
+ try:
84
+ im = Image.frombytes("1", (width, height), bitmap, "hex", "1")
85
+ except ValueError:
86
+ # deal with zero-width characters
87
+ im = Image.new("1", (width, height))
88
+
89
+ return id, int(props["ENCODING"]), bbox, im
90
+
91
+
92
+ class BdfFontFile(FontFile.FontFile):
93
+ """Font file plugin for the X11 BDF format."""
94
+
95
+ def __init__(self, fp):
96
+ super().__init__()
97
+
98
+ s = fp.readline()
99
+ if s[:13] != b"STARTFONT 2.1":
100
+ msg = "not a valid BDF file"
101
+ raise SyntaxError(msg)
102
+
103
+ props = {}
104
+ comments = []
105
+
106
+ while True:
107
+ s = fp.readline()
108
+ if not s or s[:13] == b"ENDPROPERTIES":
109
+ break
110
+ i = s.find(b" ")
111
+ props[s[:i].decode("ascii")] = s[i + 1 : -1].decode("ascii")
112
+ if s[:i] in [b"COMMENT", b"COPYRIGHT"]:
113
+ if s.find(b"LogicalFontDescription") < 0:
114
+ comments.append(s[i + 1 : -1].decode("ascii"))
115
+
116
+ while True:
117
+ c = bdf_char(fp)
118
+ if not c:
119
+ break
120
+ id, ch, (xy, dst, src), im = c
121
+ if 0 <= ch < len(self.glyph):
122
+ self.glyph[ch] = xy, dst, src, im
env/Lib/site-packages/PIL/BlpImagePlugin.py ADDED
@@ -0,0 +1,474 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Blizzard Mipmap Format (.blp)
3
+ Jerome Leclanche <[email protected]>
4
+
5
+ The contents of this file are hereby released in the public domain (CC0)
6
+ Full text of the CC0 license:
7
+ https://creativecommons.org/publicdomain/zero/1.0/
8
+
9
+ BLP1 files, used mostly in Warcraft III, are not fully supported.
10
+ All types of BLP2 files used in World of Warcraft are supported.
11
+
12
+ The BLP file structure consists of a header, up to 16 mipmaps of the
13
+ texture
14
+
15
+ Texture sizes must be powers of two, though the two dimensions do
16
+ not have to be equal; 512x256 is valid, but 512x200 is not.
17
+ The first mipmap (mipmap #0) is the full size image; each subsequent
18
+ mipmap halves both dimensions. The final mipmap should be 1x1.
19
+
20
+ BLP files come in many different flavours:
21
+ * JPEG-compressed (type == 0) - only supported for BLP1.
22
+ * RAW images (type == 1, encoding == 1). Each mipmap is stored as an
23
+ array of 8-bit values, one per pixel, left to right, top to bottom.
24
+ Each value is an index to the palette.
25
+ * DXT-compressed (type == 1, encoding == 2):
26
+ - DXT1 compression is used if alpha_encoding == 0.
27
+ - An additional alpha bit is used if alpha_depth == 1.
28
+ - DXT3 compression is used if alpha_encoding == 1.
29
+ - DXT5 compression is used if alpha_encoding == 7.
30
+ """
31
+
32
+ import os
33
+ import struct
34
+ from enum import IntEnum
35
+ from io import BytesIO
36
+
37
+ from . import Image, ImageFile
38
+
39
+
40
+ class Format(IntEnum):
41
+ JPEG = 0
42
+
43
+
44
+ class Encoding(IntEnum):
45
+ UNCOMPRESSED = 1
46
+ DXT = 2
47
+ UNCOMPRESSED_RAW_BGRA = 3
48
+
49
+
50
+ class AlphaEncoding(IntEnum):
51
+ DXT1 = 0
52
+ DXT3 = 1
53
+ DXT5 = 7
54
+
55
+
56
+ def unpack_565(i):
57
+ return ((i >> 11) & 0x1F) << 3, ((i >> 5) & 0x3F) << 2, (i & 0x1F) << 3
58
+
59
+
60
+ def decode_dxt1(data, alpha=False):
61
+ """
62
+ input: one "row" of data (i.e. will produce 4*width pixels)
63
+ """
64
+
65
+ blocks = len(data) // 8 # number of blocks in row
66
+ ret = (bytearray(), bytearray(), bytearray(), bytearray())
67
+
68
+ for block in range(blocks):
69
+ # Decode next 8-byte block.
70
+ idx = block * 8
71
+ color0, color1, bits = struct.unpack_from("<HHI", data, idx)
72
+
73
+ r0, g0, b0 = unpack_565(color0)
74
+ r1, g1, b1 = unpack_565(color1)
75
+
76
+ # Decode this block into 4x4 pixels
77
+ # Accumulate the results onto our 4 row accumulators
78
+ for j in range(4):
79
+ for i in range(4):
80
+ # get next control op and generate a pixel
81
+
82
+ control = bits & 3
83
+ bits = bits >> 2
84
+
85
+ a = 0xFF
86
+ if control == 0:
87
+ r, g, b = r0, g0, b0
88
+ elif control == 1:
89
+ r, g, b = r1, g1, b1
90
+ elif control == 2:
91
+ if color0 > color1:
92
+ r = (2 * r0 + r1) // 3
93
+ g = (2 * g0 + g1) // 3
94
+ b = (2 * b0 + b1) // 3
95
+ else:
96
+ r = (r0 + r1) // 2
97
+ g = (g0 + g1) // 2
98
+ b = (b0 + b1) // 2
99
+ elif control == 3:
100
+ if color0 > color1:
101
+ r = (2 * r1 + r0) // 3
102
+ g = (2 * g1 + g0) // 3
103
+ b = (2 * b1 + b0) // 3
104
+ else:
105
+ r, g, b, a = 0, 0, 0, 0
106
+
107
+ if alpha:
108
+ ret[j].extend([r, g, b, a])
109
+ else:
110
+ ret[j].extend([r, g, b])
111
+
112
+ return ret
113
+
114
+
115
+ def decode_dxt3(data):
116
+ """
117
+ input: one "row" of data (i.e. will produce 4*width pixels)
118
+ """
119
+
120
+ blocks = len(data) // 16 # number of blocks in row
121
+ ret = (bytearray(), bytearray(), bytearray(), bytearray())
122
+
123
+ for block in range(blocks):
124
+ idx = block * 16
125
+ block = data[idx : idx + 16]
126
+ # Decode next 16-byte block.
127
+ bits = struct.unpack_from("<8B", block)
128
+ color0, color1 = struct.unpack_from("<HH", block, 8)
129
+
130
+ (code,) = struct.unpack_from("<I", block, 12)
131
+
132
+ r0, g0, b0 = unpack_565(color0)
133
+ r1, g1, b1 = unpack_565(color1)
134
+
135
+ for j in range(4):
136
+ high = False # Do we want the higher bits?
137
+ for i in range(4):
138
+ alphacode_index = (4 * j + i) // 2
139
+ a = bits[alphacode_index]
140
+ if high:
141
+ high = False
142
+ a >>= 4
143
+ else:
144
+ high = True
145
+ a &= 0xF
146
+ a *= 17 # We get a value between 0 and 15
147
+
148
+ color_code = (code >> 2 * (4 * j + i)) & 0x03
149
+
150
+ if color_code == 0:
151
+ r, g, b = r0, g0, b0
152
+ elif color_code == 1:
153
+ r, g, b = r1, g1, b1
154
+ elif color_code == 2:
155
+ r = (2 * r0 + r1) // 3
156
+ g = (2 * g0 + g1) // 3
157
+ b = (2 * b0 + b1) // 3
158
+ elif color_code == 3:
159
+ r = (2 * r1 + r0) // 3
160
+ g = (2 * g1 + g0) // 3
161
+ b = (2 * b1 + b0) // 3
162
+
163
+ ret[j].extend([r, g, b, a])
164
+
165
+ return ret
166
+
167
+
168
+ def decode_dxt5(data):
169
+ """
170
+ input: one "row" of data (i.e. will produce 4 * width pixels)
171
+ """
172
+
173
+ blocks = len(data) // 16 # number of blocks in row
174
+ ret = (bytearray(), bytearray(), bytearray(), bytearray())
175
+
176
+ for block in range(blocks):
177
+ idx = block * 16
178
+ block = data[idx : idx + 16]
179
+ # Decode next 16-byte block.
180
+ a0, a1 = struct.unpack_from("<BB", block)
181
+
182
+ bits = struct.unpack_from("<6B", block, 2)
183
+ alphacode1 = bits[2] | (bits[3] << 8) | (bits[4] << 16) | (bits[5] << 24)
184
+ alphacode2 = bits[0] | (bits[1] << 8)
185
+
186
+ color0, color1 = struct.unpack_from("<HH", block, 8)
187
+
188
+ (code,) = struct.unpack_from("<I", block, 12)
189
+
190
+ r0, g0, b0 = unpack_565(color0)
191
+ r1, g1, b1 = unpack_565(color1)
192
+
193
+ for j in range(4):
194
+ for i in range(4):
195
+ # get next control op and generate a pixel
196
+ alphacode_index = 3 * (4 * j + i)
197
+
198
+ if alphacode_index <= 12:
199
+ alphacode = (alphacode2 >> alphacode_index) & 0x07
200
+ elif alphacode_index == 15:
201
+ alphacode = (alphacode2 >> 15) | ((alphacode1 << 1) & 0x06)
202
+ else: # alphacode_index >= 18 and alphacode_index <= 45
203
+ alphacode = (alphacode1 >> (alphacode_index - 16)) & 0x07
204
+
205
+ if alphacode == 0:
206
+ a = a0
207
+ elif alphacode == 1:
208
+ a = a1
209
+ elif a0 > a1:
210
+ a = ((8 - alphacode) * a0 + (alphacode - 1) * a1) // 7
211
+ elif alphacode == 6:
212
+ a = 0
213
+ elif alphacode == 7:
214
+ a = 255
215
+ else:
216
+ a = ((6 - alphacode) * a0 + (alphacode - 1) * a1) // 5
217
+
218
+ color_code = (code >> 2 * (4 * j + i)) & 0x03
219
+
220
+ if color_code == 0:
221
+ r, g, b = r0, g0, b0
222
+ elif color_code == 1:
223
+ r, g, b = r1, g1, b1
224
+ elif color_code == 2:
225
+ r = (2 * r0 + r1) // 3
226
+ g = (2 * g0 + g1) // 3
227
+ b = (2 * b0 + b1) // 3
228
+ elif color_code == 3:
229
+ r = (2 * r1 + r0) // 3
230
+ g = (2 * g1 + g0) // 3
231
+ b = (2 * b1 + b0) // 3
232
+
233
+ ret[j].extend([r, g, b, a])
234
+
235
+ return ret
236
+
237
+
238
+ class BLPFormatError(NotImplementedError):
239
+ pass
240
+
241
+
242
+ def _accept(prefix):
243
+ return prefix[:4] in (b"BLP1", b"BLP2")
244
+
245
+
246
+ class BlpImageFile(ImageFile.ImageFile):
247
+ """
248
+ Blizzard Mipmap Format
249
+ """
250
+
251
+ format = "BLP"
252
+ format_description = "Blizzard Mipmap Format"
253
+
254
+ def _open(self):
255
+ self.magic = self.fp.read(4)
256
+
257
+ self.fp.seek(5, os.SEEK_CUR)
258
+ (self._blp_alpha_depth,) = struct.unpack("<b", self.fp.read(1))
259
+
260
+ self.fp.seek(2, os.SEEK_CUR)
261
+ self._size = struct.unpack("<II", self.fp.read(8))
262
+
263
+ if self.magic in (b"BLP1", b"BLP2"):
264
+ decoder = self.magic.decode()
265
+ else:
266
+ msg = f"Bad BLP magic {repr(self.magic)}"
267
+ raise BLPFormatError(msg)
268
+
269
+ self._mode = "RGBA" if self._blp_alpha_depth else "RGB"
270
+ self.tile = [(decoder, (0, 0) + self.size, 0, (self.mode, 0, 1))]
271
+
272
+
273
+ class _BLPBaseDecoder(ImageFile.PyDecoder):
274
+ _pulls_fd = True
275
+
276
+ def decode(self, buffer):
277
+ try:
278
+ self._read_blp_header()
279
+ self._load()
280
+ except struct.error as e:
281
+ msg = "Truncated BLP file"
282
+ raise OSError(msg) from e
283
+ return -1, 0
284
+
285
+ def _read_blp_header(self):
286
+ self.fd.seek(4)
287
+ (self._blp_compression,) = struct.unpack("<i", self._safe_read(4))
288
+
289
+ (self._blp_encoding,) = struct.unpack("<b", self._safe_read(1))
290
+ (self._blp_alpha_depth,) = struct.unpack("<b", self._safe_read(1))
291
+ (self._blp_alpha_encoding,) = struct.unpack("<b", self._safe_read(1))
292
+ self.fd.seek(1, os.SEEK_CUR) # mips
293
+
294
+ self.size = struct.unpack("<II", self._safe_read(8))
295
+
296
+ if isinstance(self, BLP1Decoder):
297
+ # Only present for BLP1
298
+ (self._blp_encoding,) = struct.unpack("<i", self._safe_read(4))
299
+ self.fd.seek(4, os.SEEK_CUR) # subtype
300
+
301
+ self._blp_offsets = struct.unpack("<16I", self._safe_read(16 * 4))
302
+ self._blp_lengths = struct.unpack("<16I", self._safe_read(16 * 4))
303
+
304
+ def _safe_read(self, length):
305
+ return ImageFile._safe_read(self.fd, length)
306
+
307
+ def _read_palette(self):
308
+ ret = []
309
+ for i in range(256):
310
+ try:
311
+ b, g, r, a = struct.unpack("<4B", self._safe_read(4))
312
+ except struct.error:
313
+ break
314
+ ret.append((b, g, r, a))
315
+ return ret
316
+
317
+ def _read_bgra(self, palette):
318
+ data = bytearray()
319
+ _data = BytesIO(self._safe_read(self._blp_lengths[0]))
320
+ while True:
321
+ try:
322
+ (offset,) = struct.unpack("<B", _data.read(1))
323
+ except struct.error:
324
+ break
325
+ b, g, r, a = palette[offset]
326
+ d = (r, g, b)
327
+ if self._blp_alpha_depth:
328
+ d += (a,)
329
+ data.extend(d)
330
+ return data
331
+
332
+
333
+ class BLP1Decoder(_BLPBaseDecoder):
334
+ def _load(self):
335
+ if self._blp_compression == Format.JPEG:
336
+ self._decode_jpeg_stream()
337
+
338
+ elif self._blp_compression == 1:
339
+ if self._blp_encoding in (4, 5):
340
+ palette = self._read_palette()
341
+ data = self._read_bgra(palette)
342
+ self.set_as_raw(bytes(data))
343
+ else:
344
+ msg = f"Unsupported BLP encoding {repr(self._blp_encoding)}"
345
+ raise BLPFormatError(msg)
346
+ else:
347
+ msg = f"Unsupported BLP compression {repr(self._blp_encoding)}"
348
+ raise BLPFormatError(msg)
349
+
350
+ def _decode_jpeg_stream(self):
351
+ from .JpegImagePlugin import JpegImageFile
352
+
353
+ (jpeg_header_size,) = struct.unpack("<I", self._safe_read(4))
354
+ jpeg_header = self._safe_read(jpeg_header_size)
355
+ self._safe_read(self._blp_offsets[0] - self.fd.tell()) # What IS this?
356
+ data = self._safe_read(self._blp_lengths[0])
357
+ data = jpeg_header + data
358
+ data = BytesIO(data)
359
+ image = JpegImageFile(data)
360
+ Image._decompression_bomb_check(image.size)
361
+ if image.mode == "CMYK":
362
+ decoder_name, extents, offset, args = image.tile[0]
363
+ image.tile = [(decoder_name, extents, offset, (args[0], "CMYK"))]
364
+ r, g, b = image.convert("RGB").split()
365
+ image = Image.merge("RGB", (b, g, r))
366
+ self.set_as_raw(image.tobytes())
367
+
368
+
369
+ class BLP2Decoder(_BLPBaseDecoder):
370
+ def _load(self):
371
+ palette = self._read_palette()
372
+
373
+ self.fd.seek(self._blp_offsets[0])
374
+
375
+ if self._blp_compression == 1:
376
+ # Uncompressed or DirectX compression
377
+
378
+ if self._blp_encoding == Encoding.UNCOMPRESSED:
379
+ data = self._read_bgra(palette)
380
+
381
+ elif self._blp_encoding == Encoding.DXT:
382
+ data = bytearray()
383
+ if self._blp_alpha_encoding == AlphaEncoding.DXT1:
384
+ linesize = (self.size[0] + 3) // 4 * 8
385
+ for yb in range((self.size[1] + 3) // 4):
386
+ for d in decode_dxt1(
387
+ self._safe_read(linesize), alpha=bool(self._blp_alpha_depth)
388
+ ):
389
+ data += d
390
+
391
+ elif self._blp_alpha_encoding == AlphaEncoding.DXT3:
392
+ linesize = (self.size[0] + 3) // 4 * 16
393
+ for yb in range((self.size[1] + 3) // 4):
394
+ for d in decode_dxt3(self._safe_read(linesize)):
395
+ data += d
396
+
397
+ elif self._blp_alpha_encoding == AlphaEncoding.DXT5:
398
+ linesize = (self.size[0] + 3) // 4 * 16
399
+ for yb in range((self.size[1] + 3) // 4):
400
+ for d in decode_dxt5(self._safe_read(linesize)):
401
+ data += d
402
+ else:
403
+ msg = f"Unsupported alpha encoding {repr(self._blp_alpha_encoding)}"
404
+ raise BLPFormatError(msg)
405
+ else:
406
+ msg = f"Unknown BLP encoding {repr(self._blp_encoding)}"
407
+ raise BLPFormatError(msg)
408
+
409
+ else:
410
+ msg = f"Unknown BLP compression {repr(self._blp_compression)}"
411
+ raise BLPFormatError(msg)
412
+
413
+ self.set_as_raw(bytes(data))
414
+
415
+
416
+ class BLPEncoder(ImageFile.PyEncoder):
417
+ _pushes_fd = True
418
+
419
+ def _write_palette(self):
420
+ data = b""
421
+ palette = self.im.getpalette("RGBA", "RGBA")
422
+ for i in range(len(palette) // 4):
423
+ r, g, b, a = palette[i * 4 : (i + 1) * 4]
424
+ data += struct.pack("<4B", b, g, r, a)
425
+ while len(data) < 256 * 4:
426
+ data += b"\x00" * 4
427
+ return data
428
+
429
+ def encode(self, bufsize):
430
+ palette_data = self._write_palette()
431
+
432
+ offset = 20 + 16 * 4 * 2 + len(palette_data)
433
+ data = struct.pack("<16I", offset, *((0,) * 15))
434
+
435
+ w, h = self.im.size
436
+ data += struct.pack("<16I", w * h, *((0,) * 15))
437
+
438
+ data += palette_data
439
+
440
+ for y in range(h):
441
+ for x in range(w):
442
+ data += struct.pack("<B", self.im.getpixel((x, y)))
443
+
444
+ return len(data), 0, data
445
+
446
+
447
+ def _save(im, fp, filename):
448
+ if im.mode != "P":
449
+ msg = "Unsupported BLP image mode"
450
+ raise ValueError(msg)
451
+
452
+ magic = b"BLP1" if im.encoderinfo.get("blp_version") == "BLP1" else b"BLP2"
453
+ fp.write(magic)
454
+
455
+ fp.write(struct.pack("<i", 1)) # Uncompressed or DirectX compression
456
+ fp.write(struct.pack("<b", Encoding.UNCOMPRESSED))
457
+ fp.write(struct.pack("<b", 1 if im.palette.mode == "RGBA" else 0))
458
+ fp.write(struct.pack("<b", 0)) # alpha encoding
459
+ fp.write(struct.pack("<b", 0)) # mips
460
+ fp.write(struct.pack("<II", *im.size))
461
+ if magic == b"BLP1":
462
+ fp.write(struct.pack("<i", 5))
463
+ fp.write(struct.pack("<i", 0))
464
+
465
+ ImageFile._save(im, fp, [("BLP", (0, 0) + im.size, 0, im.mode)])
466
+
467
+
468
+ Image.register_open(BlpImageFile.format, BlpImageFile, _accept)
469
+ Image.register_extension(BlpImageFile.format, ".blp")
470
+ Image.register_decoder("BLP1", BLP1Decoder)
471
+ Image.register_decoder("BLP2", BLP2Decoder)
472
+
473
+ Image.register_save(BlpImageFile.format, _save)
474
+ Image.register_encoder("BLP", BLPEncoder)
env/Lib/site-packages/PIL/BmpImagePlugin.py ADDED
@@ -0,0 +1,471 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library.
3
+ # $Id$
4
+ #
5
+ # BMP file handler
6
+ #
7
+ # Windows (and OS/2) native bitmap storage format.
8
+ #
9
+ # history:
10
+ # 1995-09-01 fl Created
11
+ # 1996-04-30 fl Added save
12
+ # 1997-08-27 fl Fixed save of 1-bit images
13
+ # 1998-03-06 fl Load P images as L where possible
14
+ # 1998-07-03 fl Load P images as 1 where possible
15
+ # 1998-12-29 fl Handle small palettes
16
+ # 2002-12-30 fl Fixed load of 1-bit palette images
17
+ # 2003-04-21 fl Fixed load of 1-bit monochrome images
18
+ # 2003-04-23 fl Added limited support for BI_BITFIELDS compression
19
+ #
20
+ # Copyright (c) 1997-2003 by Secret Labs AB
21
+ # Copyright (c) 1995-2003 by Fredrik Lundh
22
+ #
23
+ # See the README file for information on usage and redistribution.
24
+ #
25
+
26
+
27
+ import os
28
+
29
+ from . import Image, ImageFile, ImagePalette
30
+ from ._binary import i16le as i16
31
+ from ._binary import i32le as i32
32
+ from ._binary import o8
33
+ from ._binary import o16le as o16
34
+ from ._binary import o32le as o32
35
+
36
+ #
37
+ # --------------------------------------------------------------------
38
+ # Read BMP file
39
+
40
+ BIT2MODE = {
41
+ # bits => mode, rawmode
42
+ 1: ("P", "P;1"),
43
+ 4: ("P", "P;4"),
44
+ 8: ("P", "P"),
45
+ 16: ("RGB", "BGR;15"),
46
+ 24: ("RGB", "BGR"),
47
+ 32: ("RGB", "BGRX"),
48
+ }
49
+
50
+
51
+ def _accept(prefix):
52
+ return prefix[:2] == b"BM"
53
+
54
+
55
+ def _dib_accept(prefix):
56
+ return i32(prefix) in [12, 40, 64, 108, 124]
57
+
58
+
59
+ # =============================================================================
60
+ # Image plugin for the Windows BMP format.
61
+ # =============================================================================
62
+ class BmpImageFile(ImageFile.ImageFile):
63
+ """Image plugin for the Windows Bitmap format (BMP)"""
64
+
65
+ # ------------------------------------------------------------- Description
66
+ format_description = "Windows Bitmap"
67
+ format = "BMP"
68
+
69
+ # -------------------------------------------------- BMP Compression values
70
+ COMPRESSIONS = {"RAW": 0, "RLE8": 1, "RLE4": 2, "BITFIELDS": 3, "JPEG": 4, "PNG": 5}
71
+ for k, v in COMPRESSIONS.items():
72
+ vars()[k] = v
73
+
74
+ def _bitmap(self, header=0, offset=0):
75
+ """Read relevant info about the BMP"""
76
+ read, seek = self.fp.read, self.fp.seek
77
+ if header:
78
+ seek(header)
79
+ # read bmp header size @offset 14 (this is part of the header size)
80
+ file_info = {"header_size": i32(read(4)), "direction": -1}
81
+
82
+ # -------------------- If requested, read header at a specific position
83
+ # read the rest of the bmp header, without its size
84
+ header_data = ImageFile._safe_read(self.fp, file_info["header_size"] - 4)
85
+
86
+ # -------------------------------------------------- IBM OS/2 Bitmap v1
87
+ # ----- This format has different offsets because of width/height types
88
+ if file_info["header_size"] == 12:
89
+ file_info["width"] = i16(header_data, 0)
90
+ file_info["height"] = i16(header_data, 2)
91
+ file_info["planes"] = i16(header_data, 4)
92
+ file_info["bits"] = i16(header_data, 6)
93
+ file_info["compression"] = self.RAW
94
+ file_info["palette_padding"] = 3
95
+
96
+ # --------------------------------------------- Windows Bitmap v2 to v5
97
+ # v3, OS/2 v2, v4, v5
98
+ elif file_info["header_size"] in (40, 64, 108, 124):
99
+ file_info["y_flip"] = header_data[7] == 0xFF
100
+ file_info["direction"] = 1 if file_info["y_flip"] else -1
101
+ file_info["width"] = i32(header_data, 0)
102
+ file_info["height"] = (
103
+ i32(header_data, 4)
104
+ if not file_info["y_flip"]
105
+ else 2**32 - i32(header_data, 4)
106
+ )
107
+ file_info["planes"] = i16(header_data, 8)
108
+ file_info["bits"] = i16(header_data, 10)
109
+ file_info["compression"] = i32(header_data, 12)
110
+ # byte size of pixel data
111
+ file_info["data_size"] = i32(header_data, 16)
112
+ file_info["pixels_per_meter"] = (
113
+ i32(header_data, 20),
114
+ i32(header_data, 24),
115
+ )
116
+ file_info["colors"] = i32(header_data, 28)
117
+ file_info["palette_padding"] = 4
118
+ self.info["dpi"] = tuple(x / 39.3701 for x in file_info["pixels_per_meter"])
119
+ if file_info["compression"] == self.BITFIELDS:
120
+ if len(header_data) >= 52:
121
+ for idx, mask in enumerate(
122
+ ["r_mask", "g_mask", "b_mask", "a_mask"]
123
+ ):
124
+ file_info[mask] = i32(header_data, 36 + idx * 4)
125
+ else:
126
+ # 40 byte headers only have the three components in the
127
+ # bitfields masks, ref:
128
+ # https://msdn.microsoft.com/en-us/library/windows/desktop/dd183376(v=vs.85).aspx
129
+ # See also
130
+ # https://github.com/python-pillow/Pillow/issues/1293
131
+ # There is a 4th component in the RGBQuad, in the alpha
132
+ # location, but it is listed as a reserved component,
133
+ # and it is not generally an alpha channel
134
+ file_info["a_mask"] = 0x0
135
+ for mask in ["r_mask", "g_mask", "b_mask"]:
136
+ file_info[mask] = i32(read(4))
137
+ file_info["rgb_mask"] = (
138
+ file_info["r_mask"],
139
+ file_info["g_mask"],
140
+ file_info["b_mask"],
141
+ )
142
+ file_info["rgba_mask"] = (
143
+ file_info["r_mask"],
144
+ file_info["g_mask"],
145
+ file_info["b_mask"],
146
+ file_info["a_mask"],
147
+ )
148
+ else:
149
+ msg = f"Unsupported BMP header type ({file_info['header_size']})"
150
+ raise OSError(msg)
151
+
152
+ # ------------------ Special case : header is reported 40, which
153
+ # ---------------------- is shorter than real size for bpp >= 16
154
+ self._size = file_info["width"], file_info["height"]
155
+
156
+ # ------- If color count was not found in the header, compute from bits
157
+ file_info["colors"] = (
158
+ file_info["colors"]
159
+ if file_info.get("colors", 0)
160
+ else (1 << file_info["bits"])
161
+ )
162
+ if offset == 14 + file_info["header_size"] and file_info["bits"] <= 8:
163
+ offset += 4 * file_info["colors"]
164
+
165
+ # ---------------------- Check bit depth for unusual unsupported values
166
+ self._mode, raw_mode = BIT2MODE.get(file_info["bits"], (None, None))
167
+ if self.mode is None:
168
+ msg = f"Unsupported BMP pixel depth ({file_info['bits']})"
169
+ raise OSError(msg)
170
+
171
+ # ---------------- Process BMP with Bitfields compression (not palette)
172
+ decoder_name = "raw"
173
+ if file_info["compression"] == self.BITFIELDS:
174
+ SUPPORTED = {
175
+ 32: [
176
+ (0xFF0000, 0xFF00, 0xFF, 0x0),
177
+ (0xFF000000, 0xFF0000, 0xFF00, 0x0),
178
+ (0xFF000000, 0xFF0000, 0xFF00, 0xFF),
179
+ (0xFF, 0xFF00, 0xFF0000, 0xFF000000),
180
+ (0xFF0000, 0xFF00, 0xFF, 0xFF000000),
181
+ (0x0, 0x0, 0x0, 0x0),
182
+ ],
183
+ 24: [(0xFF0000, 0xFF00, 0xFF)],
184
+ 16: [(0xF800, 0x7E0, 0x1F), (0x7C00, 0x3E0, 0x1F)],
185
+ }
186
+ MASK_MODES = {
187
+ (32, (0xFF0000, 0xFF00, 0xFF, 0x0)): "BGRX",
188
+ (32, (0xFF000000, 0xFF0000, 0xFF00, 0x0)): "XBGR",
189
+ (32, (0xFF000000, 0xFF0000, 0xFF00, 0xFF)): "ABGR",
190
+ (32, (0xFF, 0xFF00, 0xFF0000, 0xFF000000)): "RGBA",
191
+ (32, (0xFF0000, 0xFF00, 0xFF, 0xFF000000)): "BGRA",
192
+ (32, (0x0, 0x0, 0x0, 0x0)): "BGRA",
193
+ (24, (0xFF0000, 0xFF00, 0xFF)): "BGR",
194
+ (16, (0xF800, 0x7E0, 0x1F)): "BGR;16",
195
+ (16, (0x7C00, 0x3E0, 0x1F)): "BGR;15",
196
+ }
197
+ if file_info["bits"] in SUPPORTED:
198
+ if (
199
+ file_info["bits"] == 32
200
+ and file_info["rgba_mask"] in SUPPORTED[file_info["bits"]]
201
+ ):
202
+ raw_mode = MASK_MODES[(file_info["bits"], file_info["rgba_mask"])]
203
+ self._mode = "RGBA" if "A" in raw_mode else self.mode
204
+ elif (
205
+ file_info["bits"] in (24, 16)
206
+ and file_info["rgb_mask"] in SUPPORTED[file_info["bits"]]
207
+ ):
208
+ raw_mode = MASK_MODES[(file_info["bits"], file_info["rgb_mask"])]
209
+ else:
210
+ msg = "Unsupported BMP bitfields layout"
211
+ raise OSError(msg)
212
+ else:
213
+ msg = "Unsupported BMP bitfields layout"
214
+ raise OSError(msg)
215
+ elif file_info["compression"] == self.RAW:
216
+ if file_info["bits"] == 32 and header == 22: # 32-bit .cur offset
217
+ raw_mode, self._mode = "BGRA", "RGBA"
218
+ elif file_info["compression"] in (self.RLE8, self.RLE4):
219
+ decoder_name = "bmp_rle"
220
+ else:
221
+ msg = f"Unsupported BMP compression ({file_info['compression']})"
222
+ raise OSError(msg)
223
+
224
+ # --------------- Once the header is processed, process the palette/LUT
225
+ if self.mode == "P": # Paletted for 1, 4 and 8 bit images
226
+ # ---------------------------------------------------- 1-bit images
227
+ if not (0 < file_info["colors"] <= 65536):
228
+ msg = f"Unsupported BMP Palette size ({file_info['colors']})"
229
+ raise OSError(msg)
230
+ else:
231
+ padding = file_info["palette_padding"]
232
+ palette = read(padding * file_info["colors"])
233
+ greyscale = True
234
+ indices = (
235
+ (0, 255)
236
+ if file_info["colors"] == 2
237
+ else list(range(file_info["colors"]))
238
+ )
239
+
240
+ # ----------------- Check if greyscale and ignore palette if so
241
+ for ind, val in enumerate(indices):
242
+ rgb = palette[ind * padding : ind * padding + 3]
243
+ if rgb != o8(val) * 3:
244
+ greyscale = False
245
+
246
+ # ------- If all colors are grey, white or black, ditch palette
247
+ if greyscale:
248
+ self._mode = "1" if file_info["colors"] == 2 else "L"
249
+ raw_mode = self.mode
250
+ else:
251
+ self._mode = "P"
252
+ self.palette = ImagePalette.raw(
253
+ "BGRX" if padding == 4 else "BGR", palette
254
+ )
255
+
256
+ # ---------------------------- Finally set the tile data for the plugin
257
+ self.info["compression"] = file_info["compression"]
258
+ args = [raw_mode]
259
+ if decoder_name == "bmp_rle":
260
+ args.append(file_info["compression"] == self.RLE4)
261
+ else:
262
+ args.append(((file_info["width"] * file_info["bits"] + 31) >> 3) & (~3))
263
+ args.append(file_info["direction"])
264
+ self.tile = [
265
+ (
266
+ decoder_name,
267
+ (0, 0, file_info["width"], file_info["height"]),
268
+ offset or self.fp.tell(),
269
+ tuple(args),
270
+ )
271
+ ]
272
+
273
+ def _open(self):
274
+ """Open file, check magic number and read header"""
275
+ # read 14 bytes: magic number, filesize, reserved, header final offset
276
+ head_data = self.fp.read(14)
277
+ # choke if the file does not have the required magic bytes
278
+ if not _accept(head_data):
279
+ msg = "Not a BMP file"
280
+ raise SyntaxError(msg)
281
+ # read the start position of the BMP image data (u32)
282
+ offset = i32(head_data, 10)
283
+ # load bitmap information (offset=raster info)
284
+ self._bitmap(offset=offset)
285
+
286
+
287
+ class BmpRleDecoder(ImageFile.PyDecoder):
288
+ _pulls_fd = True
289
+
290
+ def decode(self, buffer):
291
+ rle4 = self.args[1]
292
+ data = bytearray()
293
+ x = 0
294
+ while len(data) < self.state.xsize * self.state.ysize:
295
+ pixels = self.fd.read(1)
296
+ byte = self.fd.read(1)
297
+ if not pixels or not byte:
298
+ break
299
+ num_pixels = pixels[0]
300
+ if num_pixels:
301
+ # encoded mode
302
+ if x + num_pixels > self.state.xsize:
303
+ # Too much data for row
304
+ num_pixels = max(0, self.state.xsize - x)
305
+ if rle4:
306
+ first_pixel = o8(byte[0] >> 4)
307
+ second_pixel = o8(byte[0] & 0x0F)
308
+ for index in range(num_pixels):
309
+ if index % 2 == 0:
310
+ data += first_pixel
311
+ else:
312
+ data += second_pixel
313
+ else:
314
+ data += byte * num_pixels
315
+ x += num_pixels
316
+ else:
317
+ if byte[0] == 0:
318
+ # end of line
319
+ while len(data) % self.state.xsize != 0:
320
+ data += b"\x00"
321
+ x = 0
322
+ elif byte[0] == 1:
323
+ # end of bitmap
324
+ break
325
+ elif byte[0] == 2:
326
+ # delta
327
+ bytes_read = self.fd.read(2)
328
+ if len(bytes_read) < 2:
329
+ break
330
+ right, up = self.fd.read(2)
331
+ data += b"\x00" * (right + up * self.state.xsize)
332
+ x = len(data) % self.state.xsize
333
+ else:
334
+ # absolute mode
335
+ if rle4:
336
+ # 2 pixels per byte
337
+ byte_count = byte[0] // 2
338
+ bytes_read = self.fd.read(byte_count)
339
+ for byte_read in bytes_read:
340
+ data += o8(byte_read >> 4)
341
+ data += o8(byte_read & 0x0F)
342
+ else:
343
+ byte_count = byte[0]
344
+ bytes_read = self.fd.read(byte_count)
345
+ data += bytes_read
346
+ if len(bytes_read) < byte_count:
347
+ break
348
+ x += byte[0]
349
+
350
+ # align to 16-bit word boundary
351
+ if self.fd.tell() % 2 != 0:
352
+ self.fd.seek(1, os.SEEK_CUR)
353
+ rawmode = "L" if self.mode == "L" else "P"
354
+ self.set_as_raw(bytes(data), (rawmode, 0, self.args[-1]))
355
+ return -1, 0
356
+
357
+
358
+ # =============================================================================
359
+ # Image plugin for the DIB format (BMP alias)
360
+ # =============================================================================
361
+ class DibImageFile(BmpImageFile):
362
+ format = "DIB"
363
+ format_description = "Windows Bitmap"
364
+
365
+ def _open(self):
366
+ self._bitmap()
367
+
368
+
369
+ #
370
+ # --------------------------------------------------------------------
371
+ # Write BMP file
372
+
373
+
374
+ SAVE = {
375
+ "1": ("1", 1, 2),
376
+ "L": ("L", 8, 256),
377
+ "P": ("P", 8, 256),
378
+ "RGB": ("BGR", 24, 0),
379
+ "RGBA": ("BGRA", 32, 0),
380
+ }
381
+
382
+
383
+ def _dib_save(im, fp, filename):
384
+ _save(im, fp, filename, False)
385
+
386
+
387
+ def _save(im, fp, filename, bitmap_header=True):
388
+ try:
389
+ rawmode, bits, colors = SAVE[im.mode]
390
+ except KeyError as e:
391
+ msg = f"cannot write mode {im.mode} as BMP"
392
+ raise OSError(msg) from e
393
+
394
+ info = im.encoderinfo
395
+
396
+ dpi = info.get("dpi", (96, 96))
397
+
398
+ # 1 meter == 39.3701 inches
399
+ ppm = tuple(map(lambda x: int(x * 39.3701 + 0.5), dpi))
400
+
401
+ stride = ((im.size[0] * bits + 7) // 8 + 3) & (~3)
402
+ header = 40 # or 64 for OS/2 version 2
403
+ image = stride * im.size[1]
404
+
405
+ if im.mode == "1":
406
+ palette = b"".join(o8(i) * 4 for i in (0, 255))
407
+ elif im.mode == "L":
408
+ palette = b"".join(o8(i) * 4 for i in range(256))
409
+ elif im.mode == "P":
410
+ palette = im.im.getpalette("RGB", "BGRX")
411
+ colors = len(palette) // 4
412
+ else:
413
+ palette = None
414
+
415
+ # bitmap header
416
+ if bitmap_header:
417
+ offset = 14 + header + colors * 4
418
+ file_size = offset + image
419
+ if file_size > 2**32 - 1:
420
+ msg = "File size is too large for the BMP format"
421
+ raise ValueError(msg)
422
+ fp.write(
423
+ b"BM" # file type (magic)
424
+ + o32(file_size) # file size
425
+ + o32(0) # reserved
426
+ + o32(offset) # image data offset
427
+ )
428
+
429
+ # bitmap info header
430
+ fp.write(
431
+ o32(header) # info header size
432
+ + o32(im.size[0]) # width
433
+ + o32(im.size[1]) # height
434
+ + o16(1) # planes
435
+ + o16(bits) # depth
436
+ + o32(0) # compression (0=uncompressed)
437
+ + o32(image) # size of bitmap
438
+ + o32(ppm[0]) # resolution
439
+ + o32(ppm[1]) # resolution
440
+ + o32(colors) # colors used
441
+ + o32(colors) # colors important
442
+ )
443
+
444
+ fp.write(b"\0" * (header - 40)) # padding (for OS/2 format)
445
+
446
+ if palette:
447
+ fp.write(palette)
448
+
449
+ ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, stride, -1))])
450
+
451
+
452
+ #
453
+ # --------------------------------------------------------------------
454
+ # Registry
455
+
456
+
457
+ Image.register_open(BmpImageFile.format, BmpImageFile, _accept)
458
+ Image.register_save(BmpImageFile.format, _save)
459
+
460
+ Image.register_extension(BmpImageFile.format, ".bmp")
461
+
462
+ Image.register_mime(BmpImageFile.format, "image/bmp")
463
+
464
+ Image.register_decoder("bmp_rle", BmpRleDecoder)
465
+
466
+ Image.register_open(DibImageFile.format, DibImageFile, _dib_accept)
467
+ Image.register_save(DibImageFile.format, _dib_save)
468
+
469
+ Image.register_extension(DibImageFile.format, ".dib")
470
+
471
+ Image.register_mime(DibImageFile.format, "image/bmp")
env/Lib/site-packages/PIL/BufrStubImagePlugin.py ADDED
@@ -0,0 +1,73 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library
3
+ # $Id$
4
+ #
5
+ # BUFR stub adapter
6
+ #
7
+ # Copyright (c) 1996-2003 by Fredrik Lundh
8
+ #
9
+ # See the README file for information on usage and redistribution.
10
+ #
11
+
12
+ from . import Image, ImageFile
13
+
14
+ _handler = None
15
+
16
+
17
+ def register_handler(handler):
18
+ """
19
+ Install application-specific BUFR image handler.
20
+
21
+ :param handler: Handler object.
22
+ """
23
+ global _handler
24
+ _handler = handler
25
+
26
+
27
+ # --------------------------------------------------------------------
28
+ # Image adapter
29
+
30
+
31
+ def _accept(prefix):
32
+ return prefix[:4] == b"BUFR" or prefix[:4] == b"ZCZC"
33
+
34
+
35
+ class BufrStubImageFile(ImageFile.StubImageFile):
36
+ format = "BUFR"
37
+ format_description = "BUFR"
38
+
39
+ def _open(self):
40
+ offset = self.fp.tell()
41
+
42
+ if not _accept(self.fp.read(4)):
43
+ msg = "Not a BUFR file"
44
+ raise SyntaxError(msg)
45
+
46
+ self.fp.seek(offset)
47
+
48
+ # make something up
49
+ self._mode = "F"
50
+ self._size = 1, 1
51
+
52
+ loader = self._load()
53
+ if loader:
54
+ loader.open(self)
55
+
56
+ def _load(self):
57
+ return _handler
58
+
59
+
60
+ def _save(im, fp, filename):
61
+ if _handler is None or not hasattr(_handler, "save"):
62
+ msg = "BUFR save handler not installed"
63
+ raise OSError(msg)
64
+ _handler.save(im, fp, filename)
65
+
66
+
67
+ # --------------------------------------------------------------------
68
+ # Registry
69
+
70
+ Image.register_open(BufrStubImageFile.format, BufrStubImageFile, _accept)
71
+ Image.register_save(BufrStubImageFile.format, _save)
72
+
73
+ Image.register_extension(BufrStubImageFile.format, ".bufr")
env/Lib/site-packages/PIL/ContainerIO.py ADDED
@@ -0,0 +1,120 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library.
3
+ # $Id$
4
+ #
5
+ # a class to read from a container file
6
+ #
7
+ # History:
8
+ # 1995-06-18 fl Created
9
+ # 1995-09-07 fl Added readline(), readlines()
10
+ #
11
+ # Copyright (c) 1997-2001 by Secret Labs AB
12
+ # Copyright (c) 1995 by Fredrik Lundh
13
+ #
14
+ # See the README file for information on usage and redistribution.
15
+ #
16
+
17
+
18
+ import io
19
+
20
+
21
+ class ContainerIO:
22
+ """
23
+ A file object that provides read access to a part of an existing
24
+ file (for example a TAR file).
25
+ """
26
+
27
+ def __init__(self, file, offset, length):
28
+ """
29
+ Create file object.
30
+
31
+ :param file: Existing file.
32
+ :param offset: Start of region, in bytes.
33
+ :param length: Size of region, in bytes.
34
+ """
35
+ self.fh = file
36
+ self.pos = 0
37
+ self.offset = offset
38
+ self.length = length
39
+ self.fh.seek(offset)
40
+
41
+ ##
42
+ # Always false.
43
+
44
+ def isatty(self):
45
+ return False
46
+
47
+ def seek(self, offset, mode=io.SEEK_SET):
48
+ """
49
+ Move file pointer.
50
+
51
+ :param offset: Offset in bytes.
52
+ :param mode: Starting position. Use 0 for beginning of region, 1
53
+ for current offset, and 2 for end of region. You cannot move
54
+ the pointer outside the defined region.
55
+ """
56
+ if mode == 1:
57
+ self.pos = self.pos + offset
58
+ elif mode == 2:
59
+ self.pos = self.length + offset
60
+ else:
61
+ self.pos = offset
62
+ # clamp
63
+ self.pos = max(0, min(self.pos, self.length))
64
+ self.fh.seek(self.offset + self.pos)
65
+
66
+ def tell(self):
67
+ """
68
+ Get current file pointer.
69
+
70
+ :returns: Offset from start of region, in bytes.
71
+ """
72
+ return self.pos
73
+
74
+ def read(self, n=0):
75
+ """
76
+ Read data.
77
+
78
+ :param n: Number of bytes to read. If omitted or zero,
79
+ read until end of region.
80
+ :returns: An 8-bit string.
81
+ """
82
+ if n:
83
+ n = min(n, self.length - self.pos)
84
+ else:
85
+ n = self.length - self.pos
86
+ if not n: # EOF
87
+ return b"" if "b" in self.fh.mode else ""
88
+ self.pos = self.pos + n
89
+ return self.fh.read(n)
90
+
91
+ def readline(self):
92
+ """
93
+ Read a line of text.
94
+
95
+ :returns: An 8-bit string.
96
+ """
97
+ s = b"" if "b" in self.fh.mode else ""
98
+ newline_character = b"\n" if "b" in self.fh.mode else "\n"
99
+ while True:
100
+ c = self.read(1)
101
+ if not c:
102
+ break
103
+ s = s + c
104
+ if c == newline_character:
105
+ break
106
+ return s
107
+
108
+ def readlines(self):
109
+ """
110
+ Read multiple lines of text.
111
+
112
+ :returns: A list of 8-bit strings.
113
+ """
114
+ lines = []
115
+ while True:
116
+ s = self.readline()
117
+ if not s:
118
+ break
119
+ lines.append(s)
120
+ return lines
env/Lib/site-packages/PIL/CurImagePlugin.py ADDED
@@ -0,0 +1,75 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library.
3
+ # $Id$
4
+ #
5
+ # Windows Cursor support for PIL
6
+ #
7
+ # notes:
8
+ # uses BmpImagePlugin.py to read the bitmap data.
9
+ #
10
+ # history:
11
+ # 96-05-27 fl Created
12
+ #
13
+ # Copyright (c) Secret Labs AB 1997.
14
+ # Copyright (c) Fredrik Lundh 1996.
15
+ #
16
+ # See the README file for information on usage and redistribution.
17
+ #
18
+ from . import BmpImagePlugin, Image
19
+ from ._binary import i16le as i16
20
+ from ._binary import i32le as i32
21
+
22
+ #
23
+ # --------------------------------------------------------------------
24
+
25
+
26
+ def _accept(prefix):
27
+ return prefix[:4] == b"\0\0\2\0"
28
+
29
+
30
+ ##
31
+ # Image plugin for Windows Cursor files.
32
+
33
+
34
+ class CurImageFile(BmpImagePlugin.BmpImageFile):
35
+ format = "CUR"
36
+ format_description = "Windows Cursor"
37
+
38
+ def _open(self):
39
+ offset = self.fp.tell()
40
+
41
+ # check magic
42
+ s = self.fp.read(6)
43
+ if not _accept(s):
44
+ msg = "not a CUR file"
45
+ raise SyntaxError(msg)
46
+
47
+ # pick the largest cursor in the file
48
+ m = b""
49
+ for i in range(i16(s, 4)):
50
+ s = self.fp.read(16)
51
+ if not m:
52
+ m = s
53
+ elif s[0] > m[0] and s[1] > m[1]:
54
+ m = s
55
+ if not m:
56
+ msg = "No cursors were found"
57
+ raise TypeError(msg)
58
+
59
+ # load as bitmap
60
+ self._bitmap(i32(m, 12) + offset)
61
+
62
+ # patch up the bitmap height
63
+ self._size = self.size[0], self.size[1] // 2
64
+ d, e, o, a = self.tile[0]
65
+ self.tile[0] = d, (0, 0) + self.size, o, a
66
+
67
+ return
68
+
69
+
70
+ #
71
+ # --------------------------------------------------------------------
72
+
73
+ Image.register_open(CurImageFile.format, CurImageFile, _accept)
74
+
75
+ Image.register_extension(CurImageFile.format, ".cur")
env/Lib/site-packages/PIL/DcxImagePlugin.py ADDED
@@ -0,0 +1,79 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library.
3
+ # $Id$
4
+ #
5
+ # DCX file handling
6
+ #
7
+ # DCX is a container file format defined by Intel, commonly used
8
+ # for fax applications. Each DCX file consists of a directory
9
+ # (a list of file offsets) followed by a set of (usually 1-bit)
10
+ # PCX files.
11
+ #
12
+ # History:
13
+ # 1995-09-09 fl Created
14
+ # 1996-03-20 fl Properly derived from PcxImageFile.
15
+ # 1998-07-15 fl Renamed offset attribute to avoid name clash
16
+ # 2002-07-30 fl Fixed file handling
17
+ #
18
+ # Copyright (c) 1997-98 by Secret Labs AB.
19
+ # Copyright (c) 1995-96 by Fredrik Lundh.
20
+ #
21
+ # See the README file for information on usage and redistribution.
22
+ #
23
+
24
+ from . import Image
25
+ from ._binary import i32le as i32
26
+ from .PcxImagePlugin import PcxImageFile
27
+
28
+ MAGIC = 0x3ADE68B1 # QUIZ: what's this value, then?
29
+
30
+
31
+ def _accept(prefix):
32
+ return len(prefix) >= 4 and i32(prefix) == MAGIC
33
+
34
+
35
+ ##
36
+ # Image plugin for the Intel DCX format.
37
+
38
+
39
+ class DcxImageFile(PcxImageFile):
40
+ format = "DCX"
41
+ format_description = "Intel DCX"
42
+ _close_exclusive_fp_after_loading = False
43
+
44
+ def _open(self):
45
+ # Header
46
+ s = self.fp.read(4)
47
+ if not _accept(s):
48
+ msg = "not a DCX file"
49
+ raise SyntaxError(msg)
50
+
51
+ # Component directory
52
+ self._offset = []
53
+ for i in range(1024):
54
+ offset = i32(self.fp.read(4))
55
+ if not offset:
56
+ break
57
+ self._offset.append(offset)
58
+
59
+ self._fp = self.fp
60
+ self.frame = None
61
+ self.n_frames = len(self._offset)
62
+ self.is_animated = self.n_frames > 1
63
+ self.seek(0)
64
+
65
+ def seek(self, frame):
66
+ if not self._seek_check(frame):
67
+ return
68
+ self.frame = frame
69
+ self.fp = self._fp
70
+ self.fp.seek(self._offset[frame])
71
+ PcxImageFile._open(self)
72
+
73
+ def tell(self):
74
+ return self.frame
75
+
76
+
77
+ Image.register_open(DcxImageFile.format, DcxImageFile, _accept)
78
+
79
+ Image.register_extension(DcxImageFile.format, ".dcx")
env/Lib/site-packages/PIL/DdsImagePlugin.py ADDED
@@ -0,0 +1,295 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ A Pillow loader for .dds files (S3TC-compressed aka DXTC)
3
+ Jerome Leclanche <[email protected]>
4
+
5
+ Documentation:
6
+ https://web.archive.org/web/20170802060935/http://oss.sgi.com/projects/ogl-sample/registry/EXT/texture_compression_s3tc.txt
7
+
8
+ The contents of this file are hereby released in the public domain (CC0)
9
+ Full text of the CC0 license:
10
+ https://creativecommons.org/publicdomain/zero/1.0/
11
+ """
12
+
13
+ import struct
14
+ from io import BytesIO
15
+
16
+ from . import Image, ImageFile, ImagePalette
17
+ from ._binary import o32le as o32
18
+
19
+ # Magic ("DDS ")
20
+ DDS_MAGIC = 0x20534444
21
+
22
+ # DDS flags
23
+ DDSD_CAPS = 0x1
24
+ DDSD_HEIGHT = 0x2
25
+ DDSD_WIDTH = 0x4
26
+ DDSD_PITCH = 0x8
27
+ DDSD_PIXELFORMAT = 0x1000
28
+ DDSD_MIPMAPCOUNT = 0x20000
29
+ DDSD_LINEARSIZE = 0x80000
30
+ DDSD_DEPTH = 0x800000
31
+
32
+ # DDS caps
33
+ DDSCAPS_COMPLEX = 0x8
34
+ DDSCAPS_TEXTURE = 0x1000
35
+ DDSCAPS_MIPMAP = 0x400000
36
+
37
+ DDSCAPS2_CUBEMAP = 0x200
38
+ DDSCAPS2_CUBEMAP_POSITIVEX = 0x400
39
+ DDSCAPS2_CUBEMAP_NEGATIVEX = 0x800
40
+ DDSCAPS2_CUBEMAP_POSITIVEY = 0x1000
41
+ DDSCAPS2_CUBEMAP_NEGATIVEY = 0x2000
42
+ DDSCAPS2_CUBEMAP_POSITIVEZ = 0x4000
43
+ DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x8000
44
+ DDSCAPS2_VOLUME = 0x200000
45
+
46
+ # Pixel Format
47
+ DDPF_ALPHAPIXELS = 0x1
48
+ DDPF_ALPHA = 0x2
49
+ DDPF_FOURCC = 0x4
50
+ DDPF_PALETTEINDEXED8 = 0x20
51
+ DDPF_RGB = 0x40
52
+ DDPF_LUMINANCE = 0x20000
53
+
54
+
55
+ # dds.h
56
+
57
+ DDS_FOURCC = DDPF_FOURCC
58
+ DDS_RGB = DDPF_RGB
59
+ DDS_RGBA = DDPF_RGB | DDPF_ALPHAPIXELS
60
+ DDS_LUMINANCE = DDPF_LUMINANCE
61
+ DDS_LUMINANCEA = DDPF_LUMINANCE | DDPF_ALPHAPIXELS
62
+ DDS_ALPHA = DDPF_ALPHA
63
+ DDS_PAL8 = DDPF_PALETTEINDEXED8
64
+
65
+ DDS_HEADER_FLAGS_TEXTURE = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
66
+ DDS_HEADER_FLAGS_MIPMAP = DDSD_MIPMAPCOUNT
67
+ DDS_HEADER_FLAGS_VOLUME = DDSD_DEPTH
68
+ DDS_HEADER_FLAGS_PITCH = DDSD_PITCH
69
+ DDS_HEADER_FLAGS_LINEARSIZE = DDSD_LINEARSIZE
70
+
71
+ DDS_HEIGHT = DDSD_HEIGHT
72
+ DDS_WIDTH = DDSD_WIDTH
73
+
74
+ DDS_SURFACE_FLAGS_TEXTURE = DDSCAPS_TEXTURE
75
+ DDS_SURFACE_FLAGS_MIPMAP = DDSCAPS_COMPLEX | DDSCAPS_MIPMAP
76
+ DDS_SURFACE_FLAGS_CUBEMAP = DDSCAPS_COMPLEX
77
+
78
+ DDS_CUBEMAP_POSITIVEX = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEX
79
+ DDS_CUBEMAP_NEGATIVEX = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEX
80
+ DDS_CUBEMAP_POSITIVEY = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEY
81
+ DDS_CUBEMAP_NEGATIVEY = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEY
82
+ DDS_CUBEMAP_POSITIVEZ = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEZ
83
+ DDS_CUBEMAP_NEGATIVEZ = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEZ
84
+
85
+
86
+ # DXT1
87
+ DXT1_FOURCC = 0x31545844
88
+
89
+ # DXT3
90
+ DXT3_FOURCC = 0x33545844
91
+
92
+ # DXT5
93
+ DXT5_FOURCC = 0x35545844
94
+
95
+
96
+ # dxgiformat.h
97
+
98
+ DXGI_FORMAT_R8G8B8A8_TYPELESS = 27
99
+ DXGI_FORMAT_R8G8B8A8_UNORM = 28
100
+ DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = 29
101
+ DXGI_FORMAT_BC5_TYPELESS = 82
102
+ DXGI_FORMAT_BC5_UNORM = 83
103
+ DXGI_FORMAT_BC5_SNORM = 84
104
+ DXGI_FORMAT_BC6H_UF16 = 95
105
+ DXGI_FORMAT_BC6H_SF16 = 96
106
+ DXGI_FORMAT_BC7_TYPELESS = 97
107
+ DXGI_FORMAT_BC7_UNORM = 98
108
+ DXGI_FORMAT_BC7_UNORM_SRGB = 99
109
+
110
+
111
+ class DdsImageFile(ImageFile.ImageFile):
112
+ format = "DDS"
113
+ format_description = "DirectDraw Surface"
114
+
115
+ def _open(self):
116
+ if not _accept(self.fp.read(4)):
117
+ msg = "not a DDS file"
118
+ raise SyntaxError(msg)
119
+ (header_size,) = struct.unpack("<I", self.fp.read(4))
120
+ if header_size != 124:
121
+ msg = f"Unsupported header size {repr(header_size)}"
122
+ raise OSError(msg)
123
+ header_bytes = self.fp.read(header_size - 4)
124
+ if len(header_bytes) != 120:
125
+ msg = f"Incomplete header: {len(header_bytes)} bytes"
126
+ raise OSError(msg)
127
+ header = BytesIO(header_bytes)
128
+
129
+ flags, height, width = struct.unpack("<3I", header.read(12))
130
+ self._size = (width, height)
131
+ self._mode = "RGBA"
132
+
133
+ pitch, depth, mipmaps = struct.unpack("<3I", header.read(12))
134
+ struct.unpack("<11I", header.read(44)) # reserved
135
+
136
+ # pixel format
137
+ pfsize, pfflags = struct.unpack("<2I", header.read(8))
138
+ fourcc = header.read(4)
139
+ (bitcount,) = struct.unpack("<I", header.read(4))
140
+ masks = struct.unpack("<4I", header.read(16))
141
+ if pfflags & DDPF_LUMINANCE:
142
+ # Texture contains uncompressed L or LA data
143
+ if pfflags & DDPF_ALPHAPIXELS:
144
+ self._mode = "LA"
145
+ else:
146
+ self._mode = "L"
147
+
148
+ self.tile = [("raw", (0, 0) + self.size, 0, (self.mode, 0, 1))]
149
+ elif pfflags & DDPF_RGB:
150
+ # Texture contains uncompressed RGB data
151
+ masks = {mask: ["R", "G", "B", "A"][i] for i, mask in enumerate(masks)}
152
+ rawmode = ""
153
+ if pfflags & DDPF_ALPHAPIXELS:
154
+ rawmode += masks[0xFF000000]
155
+ else:
156
+ self._mode = "RGB"
157
+ rawmode += masks[0xFF0000] + masks[0xFF00] + masks[0xFF]
158
+
159
+ self.tile = [("raw", (0, 0) + self.size, 0, (rawmode[::-1], 0, 1))]
160
+ elif pfflags & DDPF_PALETTEINDEXED8:
161
+ self._mode = "P"
162
+ self.palette = ImagePalette.raw("RGBA", self.fp.read(1024))
163
+ self.tile = [("raw", (0, 0) + self.size, 0, "L")]
164
+ else:
165
+ data_start = header_size + 4
166
+ n = 0
167
+ if fourcc == b"DXT1":
168
+ self.pixel_format = "DXT1"
169
+ n = 1
170
+ elif fourcc == b"DXT3":
171
+ self.pixel_format = "DXT3"
172
+ n = 2
173
+ elif fourcc == b"DXT5":
174
+ self.pixel_format = "DXT5"
175
+ n = 3
176
+ elif fourcc == b"ATI1":
177
+ self.pixel_format = "BC4"
178
+ n = 4
179
+ self._mode = "L"
180
+ elif fourcc in (b"ATI2", b"BC5U"):
181
+ self.pixel_format = "BC5"
182
+ n = 5
183
+ self._mode = "RGB"
184
+ elif fourcc == b"BC5S":
185
+ self.pixel_format = "BC5S"
186
+ n = 5
187
+ self._mode = "RGB"
188
+ elif fourcc == b"DX10":
189
+ data_start += 20
190
+ # ignoring flags which pertain to volume textures and cubemaps
191
+ (dxgi_format,) = struct.unpack("<I", self.fp.read(4))
192
+ self.fp.read(16)
193
+ if dxgi_format in (DXGI_FORMAT_BC5_TYPELESS, DXGI_FORMAT_BC5_UNORM):
194
+ self.pixel_format = "BC5"
195
+ n = 5
196
+ self._mode = "RGB"
197
+ elif dxgi_format == DXGI_FORMAT_BC5_SNORM:
198
+ self.pixel_format = "BC5S"
199
+ n = 5
200
+ self._mode = "RGB"
201
+ elif dxgi_format == DXGI_FORMAT_BC6H_UF16:
202
+ self.pixel_format = "BC6H"
203
+ n = 6
204
+ self._mode = "RGB"
205
+ elif dxgi_format == DXGI_FORMAT_BC6H_SF16:
206
+ self.pixel_format = "BC6HS"
207
+ n = 6
208
+ self._mode = "RGB"
209
+ elif dxgi_format in (DXGI_FORMAT_BC7_TYPELESS, DXGI_FORMAT_BC7_UNORM):
210
+ self.pixel_format = "BC7"
211
+ n = 7
212
+ elif dxgi_format == DXGI_FORMAT_BC7_UNORM_SRGB:
213
+ self.pixel_format = "BC7"
214
+ self.info["gamma"] = 1 / 2.2
215
+ n = 7
216
+ elif dxgi_format in (
217
+ DXGI_FORMAT_R8G8B8A8_TYPELESS,
218
+ DXGI_FORMAT_R8G8B8A8_UNORM,
219
+ DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
220
+ ):
221
+ self.tile = [("raw", (0, 0) + self.size, 0, ("RGBA", 0, 1))]
222
+ if dxgi_format == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
223
+ self.info["gamma"] = 1 / 2.2
224
+ return
225
+ else:
226
+ msg = f"Unimplemented DXGI format {dxgi_format}"
227
+ raise NotImplementedError(msg)
228
+ else:
229
+ msg = f"Unimplemented pixel format {repr(fourcc)}"
230
+ raise NotImplementedError(msg)
231
+
232
+ self.tile = [
233
+ ("bcn", (0, 0) + self.size, data_start, (n, self.pixel_format))
234
+ ]
235
+
236
+ def load_seek(self, pos):
237
+ pass
238
+
239
+
240
+ def _save(im, fp, filename):
241
+ if im.mode not in ("RGB", "RGBA", "L", "LA"):
242
+ msg = f"cannot write mode {im.mode} as DDS"
243
+ raise OSError(msg)
244
+
245
+ rawmode = im.mode
246
+ masks = [0xFF0000, 0xFF00, 0xFF]
247
+ if im.mode in ("L", "LA"):
248
+ pixel_flags = DDPF_LUMINANCE
249
+ else:
250
+ pixel_flags = DDPF_RGB
251
+ rawmode = rawmode[::-1]
252
+ if im.mode in ("LA", "RGBA"):
253
+ pixel_flags |= DDPF_ALPHAPIXELS
254
+ masks.append(0xFF000000)
255
+
256
+ bitcount = len(masks) * 8
257
+ while len(masks) < 4:
258
+ masks.append(0)
259
+
260
+ fp.write(
261
+ o32(DDS_MAGIC)
262
+ + o32(124) # header size
263
+ + o32(
264
+ DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PITCH | DDSD_PIXELFORMAT
265
+ ) # flags
266
+ + o32(im.height)
267
+ + o32(im.width)
268
+ + o32((im.width * bitcount + 7) // 8) # pitch
269
+ + o32(0) # depth
270
+ + o32(0) # mipmaps
271
+ + o32(0) * 11 # reserved
272
+ + o32(32) # pfsize
273
+ + o32(pixel_flags) # pfflags
274
+ + o32(0) # fourcc
275
+ + o32(bitcount) # bitcount
276
+ + b"".join(o32(mask) for mask in masks) # rgbabitmask
277
+ + o32(DDSCAPS_TEXTURE) # dwCaps
278
+ + o32(0) # dwCaps2
279
+ + o32(0) # dwCaps3
280
+ + o32(0) # dwCaps4
281
+ + o32(0) # dwReserved2
282
+ )
283
+ if im.mode == "RGBA":
284
+ r, g, b, a = im.split()
285
+ im = Image.merge("RGBA", (a, r, g, b))
286
+ ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, 0, 1))])
287
+
288
+
289
+ def _accept(prefix):
290
+ return prefix[:4] == b"DDS "
291
+
292
+
293
+ Image.register_open(DdsImageFile.format, DdsImageFile, _accept)
294
+ Image.register_save(DdsImageFile.format, _save)
295
+ Image.register_extension(DdsImageFile.format, ".dds")
env/Lib/site-packages/PIL/EpsImagePlugin.py ADDED
@@ -0,0 +1,480 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library.
3
+ # $Id$
4
+ #
5
+ # EPS file handling
6
+ #
7
+ # History:
8
+ # 1995-09-01 fl Created (0.1)
9
+ # 1996-05-18 fl Don't choke on "atend" fields, Ghostscript interface (0.2)
10
+ # 1996-08-22 fl Don't choke on floating point BoundingBox values
11
+ # 1996-08-23 fl Handle files from Macintosh (0.3)
12
+ # 2001-02-17 fl Use 're' instead of 'regex' (Python 2.1) (0.4)
13
+ # 2003-09-07 fl Check gs.close status (from Federico Di Gregorio) (0.5)
14
+ # 2014-05-07 e Handling of EPS with binary preview and fixed resolution
15
+ # resizing
16
+ #
17
+ # Copyright (c) 1997-2003 by Secret Labs AB.
18
+ # Copyright (c) 1995-2003 by Fredrik Lundh
19
+ #
20
+ # See the README file for information on usage and redistribution.
21
+ #
22
+
23
+ import io
24
+ import os
25
+ import re
26
+ import subprocess
27
+ import sys
28
+ import tempfile
29
+
30
+ from . import Image, ImageFile
31
+ from ._binary import i32le as i32
32
+ from ._deprecate import deprecate
33
+
34
+ # --------------------------------------------------------------------
35
+
36
+
37
+ split = re.compile(r"^%%([^:]*):[ \t]*(.*)[ \t]*$")
38
+ field = re.compile(r"^%[%!\w]([^:]*)[ \t]*$")
39
+
40
+ gs_binary = None
41
+ gs_windows_binary = None
42
+
43
+
44
+ def has_ghostscript():
45
+ global gs_binary, gs_windows_binary
46
+ if gs_binary is None:
47
+ if sys.platform.startswith("win"):
48
+ if gs_windows_binary is None:
49
+ import shutil
50
+
51
+ for binary in ("gswin32c", "gswin64c", "gs"):
52
+ if shutil.which(binary) is not None:
53
+ gs_windows_binary = binary
54
+ break
55
+ else:
56
+ gs_windows_binary = False
57
+ gs_binary = gs_windows_binary
58
+ else:
59
+ try:
60
+ subprocess.check_call(["gs", "--version"], stdout=subprocess.DEVNULL)
61
+ gs_binary = "gs"
62
+ except OSError:
63
+ gs_binary = False
64
+ return gs_binary is not False
65
+
66
+
67
+ def Ghostscript(tile, size, fp, scale=1, transparency=False):
68
+ """Render an image using Ghostscript"""
69
+ global gs_binary
70
+ if not has_ghostscript():
71
+ msg = "Unable to locate Ghostscript on paths"
72
+ raise OSError(msg)
73
+
74
+ # Unpack decoder tile
75
+ decoder, tile, offset, data = tile[0]
76
+ length, bbox = data
77
+
78
+ # Hack to support hi-res rendering
79
+ scale = int(scale) or 1
80
+ # orig_size = size
81
+ # orig_bbox = bbox
82
+ size = (size[0] * scale, size[1] * scale)
83
+ # resolution is dependent on bbox and size
84
+ res = (
85
+ 72.0 * size[0] / (bbox[2] - bbox[0]),
86
+ 72.0 * size[1] / (bbox[3] - bbox[1]),
87
+ )
88
+
89
+ out_fd, outfile = tempfile.mkstemp()
90
+ os.close(out_fd)
91
+
92
+ infile_temp = None
93
+ if hasattr(fp, "name") and os.path.exists(fp.name):
94
+ infile = fp.name
95
+ else:
96
+ in_fd, infile_temp = tempfile.mkstemp()
97
+ os.close(in_fd)
98
+ infile = infile_temp
99
+
100
+ # Ignore length and offset!
101
+ # Ghostscript can read it
102
+ # Copy whole file to read in Ghostscript
103
+ with open(infile_temp, "wb") as f:
104
+ # fetch length of fp
105
+ fp.seek(0, io.SEEK_END)
106
+ fsize = fp.tell()
107
+ # ensure start position
108
+ # go back
109
+ fp.seek(0)
110
+ lengthfile = fsize
111
+ while lengthfile > 0:
112
+ s = fp.read(min(lengthfile, 100 * 1024))
113
+ if not s:
114
+ break
115
+ lengthfile -= len(s)
116
+ f.write(s)
117
+
118
+ device = "pngalpha" if transparency else "ppmraw"
119
+
120
+ # Build Ghostscript command
121
+ command = [
122
+ gs_binary,
123
+ "-q", # quiet mode
124
+ "-g%dx%d" % size, # set output geometry (pixels)
125
+ "-r%fx%f" % res, # set input DPI (dots per inch)
126
+ "-dBATCH", # exit after processing
127
+ "-dNOPAUSE", # don't pause between pages
128
+ "-dSAFER", # safe mode
129
+ f"-sDEVICE={device}",
130
+ f"-sOutputFile={outfile}", # output file
131
+ # adjust for image origin
132
+ "-c",
133
+ f"{-bbox[0]} {-bbox[1]} translate",
134
+ "-f",
135
+ infile, # input file
136
+ # showpage (see https://bugs.ghostscript.com/show_bug.cgi?id=698272)
137
+ "-c",
138
+ "showpage",
139
+ ]
140
+
141
+ # push data through Ghostscript
142
+ try:
143
+ startupinfo = None
144
+ if sys.platform.startswith("win"):
145
+ startupinfo = subprocess.STARTUPINFO()
146
+ startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
147
+ subprocess.check_call(command, startupinfo=startupinfo)
148
+ out_im = Image.open(outfile)
149
+ out_im.load()
150
+ finally:
151
+ try:
152
+ os.unlink(outfile)
153
+ if infile_temp:
154
+ os.unlink(infile_temp)
155
+ except OSError:
156
+ pass
157
+
158
+ im = out_im.im.copy()
159
+ out_im.close()
160
+ return im
161
+
162
+
163
+ class PSFile:
164
+ """
165
+ Wrapper for bytesio object that treats either CR or LF as end of line.
166
+ This class is no longer used internally, but kept for backwards compatibility.
167
+ """
168
+
169
+ def __init__(self, fp):
170
+ deprecate(
171
+ "PSFile",
172
+ 11,
173
+ action="If you need the functionality of this class "
174
+ "you will need to implement it yourself.",
175
+ )
176
+ self.fp = fp
177
+ self.char = None
178
+
179
+ def seek(self, offset, whence=io.SEEK_SET):
180
+ self.char = None
181
+ self.fp.seek(offset, whence)
182
+
183
+ def readline(self):
184
+ s = [self.char or b""]
185
+ self.char = None
186
+
187
+ c = self.fp.read(1)
188
+ while (c not in b"\r\n") and len(c):
189
+ s.append(c)
190
+ c = self.fp.read(1)
191
+
192
+ self.char = self.fp.read(1)
193
+ # line endings can be 1 or 2 of \r \n, in either order
194
+ if self.char in b"\r\n":
195
+ self.char = None
196
+
197
+ return b"".join(s).decode("latin-1")
198
+
199
+
200
+ def _accept(prefix):
201
+ return prefix[:4] == b"%!PS" or (len(prefix) >= 4 and i32(prefix) == 0xC6D3D0C5)
202
+
203
+
204
+ ##
205
+ # Image plugin for Encapsulated PostScript. This plugin supports only
206
+ # a few variants of this format.
207
+
208
+
209
+ class EpsImageFile(ImageFile.ImageFile):
210
+ """EPS File Parser for the Python Imaging Library"""
211
+
212
+ format = "EPS"
213
+ format_description = "Encapsulated Postscript"
214
+
215
+ mode_map = {1: "L", 2: "LAB", 3: "RGB", 4: "CMYK"}
216
+
217
+ def _open(self):
218
+ (length, offset) = self._find_offset(self.fp)
219
+
220
+ # go to offset - start of "%!PS"
221
+ self.fp.seek(offset)
222
+
223
+ self._mode = "RGB"
224
+ self._size = None
225
+
226
+ byte_arr = bytearray(255)
227
+ bytes_mv = memoryview(byte_arr)
228
+ bytes_read = 0
229
+ reading_header_comments = True
230
+ reading_trailer_comments = False
231
+ trailer_reached = False
232
+
233
+ def check_required_header_comments():
234
+ if "PS-Adobe" not in self.info:
235
+ msg = 'EPS header missing "%!PS-Adobe" comment'
236
+ raise SyntaxError(msg)
237
+ if "BoundingBox" not in self.info:
238
+ msg = 'EPS header missing "%%BoundingBox" comment'
239
+ raise SyntaxError(msg)
240
+
241
+ def _read_comment(s):
242
+ nonlocal reading_trailer_comments
243
+ try:
244
+ m = split.match(s)
245
+ except re.error as e:
246
+ msg = "not an EPS file"
247
+ raise SyntaxError(msg) from e
248
+
249
+ if m:
250
+ k, v = m.group(1, 2)
251
+ self.info[k] = v
252
+ if k == "BoundingBox":
253
+ if v == "(atend)":
254
+ reading_trailer_comments = True
255
+ elif not self._size or (
256
+ trailer_reached and reading_trailer_comments
257
+ ):
258
+ try:
259
+ # Note: The DSC spec says that BoundingBox
260
+ # fields should be integers, but some drivers
261
+ # put floating point values there anyway.
262
+ box = [int(float(i)) for i in v.split()]
263
+ self._size = box[2] - box[0], box[3] - box[1]
264
+ self.tile = [
265
+ ("eps", (0, 0) + self.size, offset, (length, box))
266
+ ]
267
+ except Exception:
268
+ pass
269
+ return True
270
+
271
+ while True:
272
+ byte = self.fp.read(1)
273
+ if byte == b"":
274
+ # if we didn't read a byte we must be at the end of the file
275
+ if bytes_read == 0:
276
+ break
277
+ elif byte in b"\r\n":
278
+ # if we read a line ending character, ignore it and parse what
279
+ # we have already read. if we haven't read any other characters,
280
+ # continue reading
281
+ if bytes_read == 0:
282
+ continue
283
+ else:
284
+ # ASCII/hexadecimal lines in an EPS file must not exceed
285
+ # 255 characters, not including line ending characters
286
+ if bytes_read >= 255:
287
+ # only enforce this for lines starting with a "%",
288
+ # otherwise assume it's binary data
289
+ if byte_arr[0] == ord("%"):
290
+ msg = "not an EPS file"
291
+ raise SyntaxError(msg)
292
+ else:
293
+ if reading_header_comments:
294
+ check_required_header_comments()
295
+ reading_header_comments = False
296
+ # reset bytes_read so we can keep reading
297
+ # data until the end of the line
298
+ bytes_read = 0
299
+ byte_arr[bytes_read] = byte[0]
300
+ bytes_read += 1
301
+ continue
302
+
303
+ if reading_header_comments:
304
+ # Load EPS header
305
+
306
+ # if this line doesn't start with a "%",
307
+ # or does start with "%%EndComments",
308
+ # then we've reached the end of the header/comments
309
+ if byte_arr[0] != ord("%") or bytes_mv[:13] == b"%%EndComments":
310
+ check_required_header_comments()
311
+ reading_header_comments = False
312
+ continue
313
+
314
+ s = str(bytes_mv[:bytes_read], "latin-1")
315
+ if not _read_comment(s):
316
+ m = field.match(s)
317
+ if m:
318
+ k = m.group(1)
319
+ if k[:8] == "PS-Adobe":
320
+ self.info["PS-Adobe"] = k[9:]
321
+ else:
322
+ self.info[k] = ""
323
+ elif s[0] == "%":
324
+ # handle non-DSC PostScript comments that some
325
+ # tools mistakenly put in the Comments section
326
+ pass
327
+ else:
328
+ msg = "bad EPS header"
329
+ raise OSError(msg)
330
+ elif bytes_mv[:11] == b"%ImageData:":
331
+ # Check for an "ImageData" descriptor
332
+ # https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/#50577413_pgfId-1035096
333
+
334
+ # Values:
335
+ # columns
336
+ # rows
337
+ # bit depth (1 or 8)
338
+ # mode (1: L, 2: LAB, 3: RGB, 4: CMYK)
339
+ # number of padding channels
340
+ # block size (number of bytes per row per channel)
341
+ # binary/ascii (1: binary, 2: ascii)
342
+ # data start identifier (the image data follows after a single line
343
+ # consisting only of this quoted value)
344
+ image_data_values = byte_arr[11:bytes_read].split(None, 7)
345
+ columns, rows, bit_depth, mode_id = (
346
+ int(value) for value in image_data_values[:4]
347
+ )
348
+
349
+ if bit_depth == 1:
350
+ self._mode = "1"
351
+ elif bit_depth == 8:
352
+ try:
353
+ self._mode = self.mode_map[mode_id]
354
+ except ValueError:
355
+ break
356
+ else:
357
+ break
358
+
359
+ self._size = columns, rows
360
+ return
361
+ elif trailer_reached and reading_trailer_comments:
362
+ # Load EPS trailer
363
+
364
+ # if this line starts with "%%EOF",
365
+ # then we've reached the end of the file
366
+ if bytes_mv[:5] == b"%%EOF":
367
+ break
368
+
369
+ s = str(bytes_mv[:bytes_read], "latin-1")
370
+ _read_comment(s)
371
+ elif bytes_mv[:9] == b"%%Trailer":
372
+ trailer_reached = True
373
+ bytes_read = 0
374
+
375
+ check_required_header_comments()
376
+
377
+ if not self._size:
378
+ msg = "cannot determine EPS bounding box"
379
+ raise OSError(msg)
380
+
381
+ def _find_offset(self, fp):
382
+ s = fp.read(4)
383
+
384
+ if s == b"%!PS":
385
+ # for HEAD without binary preview
386
+ fp.seek(0, io.SEEK_END)
387
+ length = fp.tell()
388
+ offset = 0
389
+ elif i32(s) == 0xC6D3D0C5:
390
+ # FIX for: Some EPS file not handled correctly / issue #302
391
+ # EPS can contain binary data
392
+ # or start directly with latin coding
393
+ # more info see:
394
+ # https://web.archive.org/web/20160528181353/http://partners.adobe.com/public/developer/en/ps/5002.EPSF_Spec.pdf
395
+ s = fp.read(8)
396
+ offset = i32(s)
397
+ length = i32(s, 4)
398
+ else:
399
+ msg = "not an EPS file"
400
+ raise SyntaxError(msg)
401
+
402
+ return length, offset
403
+
404
+ def load(self, scale=1, transparency=False):
405
+ # Load EPS via Ghostscript
406
+ if self.tile:
407
+ self.im = Ghostscript(self.tile, self.size, self.fp, scale, transparency)
408
+ self._mode = self.im.mode
409
+ self._size = self.im.size
410
+ self.tile = []
411
+ return Image.Image.load(self)
412
+
413
+ def load_seek(self, *args, **kwargs):
414
+ # we can't incrementally load, so force ImageFile.parser to
415
+ # use our custom load method by defining this method.
416
+ pass
417
+
418
+
419
+ # --------------------------------------------------------------------
420
+
421
+
422
+ def _save(im, fp, filename, eps=1):
423
+ """EPS Writer for the Python Imaging Library."""
424
+
425
+ # make sure image data is available
426
+ im.load()
427
+
428
+ # determine PostScript image mode
429
+ if im.mode == "L":
430
+ operator = (8, 1, b"image")
431
+ elif im.mode == "RGB":
432
+ operator = (8, 3, b"false 3 colorimage")
433
+ elif im.mode == "CMYK":
434
+ operator = (8, 4, b"false 4 colorimage")
435
+ else:
436
+ msg = "image mode is not supported"
437
+ raise ValueError(msg)
438
+
439
+ if eps:
440
+ # write EPS header
441
+ fp.write(b"%!PS-Adobe-3.0 EPSF-3.0\n")
442
+ fp.write(b"%%Creator: PIL 0.1 EpsEncode\n")
443
+ # fp.write("%%CreationDate: %s"...)
444
+ fp.write(b"%%%%BoundingBox: 0 0 %d %d\n" % im.size)
445
+ fp.write(b"%%Pages: 1\n")
446
+ fp.write(b"%%EndComments\n")
447
+ fp.write(b"%%Page: 1 1\n")
448
+ fp.write(b"%%ImageData: %d %d " % im.size)
449
+ fp.write(b'%d %d 0 1 1 "%s"\n' % operator)
450
+
451
+ # image header
452
+ fp.write(b"gsave\n")
453
+ fp.write(b"10 dict begin\n")
454
+ fp.write(b"/buf %d string def\n" % (im.size[0] * operator[1]))
455
+ fp.write(b"%d %d scale\n" % im.size)
456
+ fp.write(b"%d %d 8\n" % im.size) # <= bits
457
+ fp.write(b"[%d 0 0 -%d 0 %d]\n" % (im.size[0], im.size[1], im.size[1]))
458
+ fp.write(b"{ currentfile buf readhexstring pop } bind\n")
459
+ fp.write(operator[2] + b"\n")
460
+ if hasattr(fp, "flush"):
461
+ fp.flush()
462
+
463
+ ImageFile._save(im, fp, [("eps", (0, 0) + im.size, 0, None)])
464
+
465
+ fp.write(b"\n%%%%EndBinary\n")
466
+ fp.write(b"grestore end\n")
467
+ if hasattr(fp, "flush"):
468
+ fp.flush()
469
+
470
+
471
+ # --------------------------------------------------------------------
472
+
473
+
474
+ Image.register_open(EpsImageFile.format, EpsImageFile, _accept)
475
+
476
+ Image.register_save(EpsImageFile.format, _save)
477
+
478
+ Image.register_extensions(EpsImageFile.format, [".ps", ".eps"])
479
+
480
+ Image.register_mime(EpsImageFile.format, "application/postscript")
env/Lib/site-packages/PIL/ExifTags.py ADDED
@@ -0,0 +1,380 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library.
3
+ # $Id$
4
+ #
5
+ # EXIF tags
6
+ #
7
+ # Copyright (c) 2003 by Secret Labs AB
8
+ #
9
+ # See the README file for information on usage and redistribution.
10
+ #
11
+
12
+ """
13
+ This module provides constants and clear-text names for various
14
+ well-known EXIF tags.
15
+ """
16
+
17
+ from enum import IntEnum
18
+
19
+
20
+ class Base(IntEnum):
21
+ # possibly incomplete
22
+ InteropIndex = 0x0001
23
+ ProcessingSoftware = 0x000B
24
+ NewSubfileType = 0x00FE
25
+ SubfileType = 0x00FF
26
+ ImageWidth = 0x0100
27
+ ImageLength = 0x0101
28
+ BitsPerSample = 0x0102
29
+ Compression = 0x0103
30
+ PhotometricInterpretation = 0x0106
31
+ Thresholding = 0x0107
32
+ CellWidth = 0x0108
33
+ CellLength = 0x0109
34
+ FillOrder = 0x010A
35
+ DocumentName = 0x010D
36
+ ImageDescription = 0x010E
37
+ Make = 0x010F
38
+ Model = 0x0110
39
+ StripOffsets = 0x0111
40
+ Orientation = 0x0112
41
+ SamplesPerPixel = 0x0115
42
+ RowsPerStrip = 0x0116
43
+ StripByteCounts = 0x0117
44
+ MinSampleValue = 0x0118
45
+ MaxSampleValue = 0x0119
46
+ XResolution = 0x011A
47
+ YResolution = 0x011B
48
+ PlanarConfiguration = 0x011C
49
+ PageName = 0x011D
50
+ FreeOffsets = 0x0120
51
+ FreeByteCounts = 0x0121
52
+ GrayResponseUnit = 0x0122
53
+ GrayResponseCurve = 0x0123
54
+ T4Options = 0x0124
55
+ T6Options = 0x0125
56
+ ResolutionUnit = 0x0128
57
+ PageNumber = 0x0129
58
+ TransferFunction = 0x012D
59
+ Software = 0x0131
60
+ DateTime = 0x0132
61
+ Artist = 0x013B
62
+ HostComputer = 0x013C
63
+ Predictor = 0x013D
64
+ WhitePoint = 0x013E
65
+ PrimaryChromaticities = 0x013F
66
+ ColorMap = 0x0140
67
+ HalftoneHints = 0x0141
68
+ TileWidth = 0x0142
69
+ TileLength = 0x0143
70
+ TileOffsets = 0x0144
71
+ TileByteCounts = 0x0145
72
+ SubIFDs = 0x014A
73
+ InkSet = 0x014C
74
+ InkNames = 0x014D
75
+ NumberOfInks = 0x014E
76
+ DotRange = 0x0150
77
+ TargetPrinter = 0x0151
78
+ ExtraSamples = 0x0152
79
+ SampleFormat = 0x0153
80
+ SMinSampleValue = 0x0154
81
+ SMaxSampleValue = 0x0155
82
+ TransferRange = 0x0156
83
+ ClipPath = 0x0157
84
+ XClipPathUnits = 0x0158
85
+ YClipPathUnits = 0x0159
86
+ Indexed = 0x015A
87
+ JPEGTables = 0x015B
88
+ OPIProxy = 0x015F
89
+ JPEGProc = 0x0200
90
+ JpegIFOffset = 0x0201
91
+ JpegIFByteCount = 0x0202
92
+ JpegRestartInterval = 0x0203
93
+ JpegLosslessPredictors = 0x0205
94
+ JpegPointTransforms = 0x0206
95
+ JpegQTables = 0x0207
96
+ JpegDCTables = 0x0208
97
+ JpegACTables = 0x0209
98
+ YCbCrCoefficients = 0x0211
99
+ YCbCrSubSampling = 0x0212
100
+ YCbCrPositioning = 0x0213
101
+ ReferenceBlackWhite = 0x0214
102
+ XMLPacket = 0x02BC
103
+ RelatedImageFileFormat = 0x1000
104
+ RelatedImageWidth = 0x1001
105
+ RelatedImageLength = 0x1002
106
+ Rating = 0x4746
107
+ RatingPercent = 0x4749
108
+ ImageID = 0x800D
109
+ CFARepeatPatternDim = 0x828D
110
+ BatteryLevel = 0x828F
111
+ Copyright = 0x8298
112
+ ExposureTime = 0x829A
113
+ FNumber = 0x829D
114
+ IPTCNAA = 0x83BB
115
+ ImageResources = 0x8649
116
+ ExifOffset = 0x8769
117
+ InterColorProfile = 0x8773
118
+ ExposureProgram = 0x8822
119
+ SpectralSensitivity = 0x8824
120
+ GPSInfo = 0x8825
121
+ ISOSpeedRatings = 0x8827
122
+ OECF = 0x8828
123
+ Interlace = 0x8829
124
+ TimeZoneOffset = 0x882A
125
+ SelfTimerMode = 0x882B
126
+ SensitivityType = 0x8830
127
+ StandardOutputSensitivity = 0x8831
128
+ RecommendedExposureIndex = 0x8832
129
+ ISOSpeed = 0x8833
130
+ ISOSpeedLatitudeyyy = 0x8834
131
+ ISOSpeedLatitudezzz = 0x8835
132
+ ExifVersion = 0x9000
133
+ DateTimeOriginal = 0x9003
134
+ DateTimeDigitized = 0x9004
135
+ OffsetTime = 0x9010
136
+ OffsetTimeOriginal = 0x9011
137
+ OffsetTimeDigitized = 0x9012
138
+ ComponentsConfiguration = 0x9101
139
+ CompressedBitsPerPixel = 0x9102
140
+ ShutterSpeedValue = 0x9201
141
+ ApertureValue = 0x9202
142
+ BrightnessValue = 0x9203
143
+ ExposureBiasValue = 0x9204
144
+ MaxApertureValue = 0x9205
145
+ SubjectDistance = 0x9206
146
+ MeteringMode = 0x9207
147
+ LightSource = 0x9208
148
+ Flash = 0x9209
149
+ FocalLength = 0x920A
150
+ Noise = 0x920D
151
+ ImageNumber = 0x9211
152
+ SecurityClassification = 0x9212
153
+ ImageHistory = 0x9213
154
+ TIFFEPStandardID = 0x9216
155
+ MakerNote = 0x927C
156
+ UserComment = 0x9286
157
+ SubsecTime = 0x9290
158
+ SubsecTimeOriginal = 0x9291
159
+ SubsecTimeDigitized = 0x9292
160
+ AmbientTemperature = 0x9400
161
+ Humidity = 0x9401
162
+ Pressure = 0x9402
163
+ WaterDepth = 0x9403
164
+ Acceleration = 0x9404
165
+ CameraElevationAngle = 0x9405
166
+ XPTitle = 0x9C9B
167
+ XPComment = 0x9C9C
168
+ XPAuthor = 0x9C9D
169
+ XPKeywords = 0x9C9E
170
+ XPSubject = 0x9C9F
171
+ FlashPixVersion = 0xA000
172
+ ColorSpace = 0xA001
173
+ ExifImageWidth = 0xA002
174
+ ExifImageHeight = 0xA003
175
+ RelatedSoundFile = 0xA004
176
+ ExifInteroperabilityOffset = 0xA005
177
+ FlashEnergy = 0xA20B
178
+ SpatialFrequencyResponse = 0xA20C
179
+ FocalPlaneXResolution = 0xA20E
180
+ FocalPlaneYResolution = 0xA20F
181
+ FocalPlaneResolutionUnit = 0xA210
182
+ SubjectLocation = 0xA214
183
+ ExposureIndex = 0xA215
184
+ SensingMethod = 0xA217
185
+ FileSource = 0xA300
186
+ SceneType = 0xA301
187
+ CFAPattern = 0xA302
188
+ CustomRendered = 0xA401
189
+ ExposureMode = 0xA402
190
+ WhiteBalance = 0xA403
191
+ DigitalZoomRatio = 0xA404
192
+ FocalLengthIn35mmFilm = 0xA405
193
+ SceneCaptureType = 0xA406
194
+ GainControl = 0xA407
195
+ Contrast = 0xA408
196
+ Saturation = 0xA409
197
+ Sharpness = 0xA40A
198
+ DeviceSettingDescription = 0xA40B
199
+ SubjectDistanceRange = 0xA40C
200
+ ImageUniqueID = 0xA420
201
+ CameraOwnerName = 0xA430
202
+ BodySerialNumber = 0xA431
203
+ LensSpecification = 0xA432
204
+ LensMake = 0xA433
205
+ LensModel = 0xA434
206
+ LensSerialNumber = 0xA435
207
+ CompositeImage = 0xA460
208
+ CompositeImageCount = 0xA461
209
+ CompositeImageExposureTimes = 0xA462
210
+ Gamma = 0xA500
211
+ PrintImageMatching = 0xC4A5
212
+ DNGVersion = 0xC612
213
+ DNGBackwardVersion = 0xC613
214
+ UniqueCameraModel = 0xC614
215
+ LocalizedCameraModel = 0xC615
216
+ CFAPlaneColor = 0xC616
217
+ CFALayout = 0xC617
218
+ LinearizationTable = 0xC618
219
+ BlackLevelRepeatDim = 0xC619
220
+ BlackLevel = 0xC61A
221
+ BlackLevelDeltaH = 0xC61B
222
+ BlackLevelDeltaV = 0xC61C
223
+ WhiteLevel = 0xC61D
224
+ DefaultScale = 0xC61E
225
+ DefaultCropOrigin = 0xC61F
226
+ DefaultCropSize = 0xC620
227
+ ColorMatrix1 = 0xC621
228
+ ColorMatrix2 = 0xC622
229
+ CameraCalibration1 = 0xC623
230
+ CameraCalibration2 = 0xC624
231
+ ReductionMatrix1 = 0xC625
232
+ ReductionMatrix2 = 0xC626
233
+ AnalogBalance = 0xC627
234
+ AsShotNeutral = 0xC628
235
+ AsShotWhiteXY = 0xC629
236
+ BaselineExposure = 0xC62A
237
+ BaselineNoise = 0xC62B
238
+ BaselineSharpness = 0xC62C
239
+ BayerGreenSplit = 0xC62D
240
+ LinearResponseLimit = 0xC62E
241
+ CameraSerialNumber = 0xC62F
242
+ LensInfo = 0xC630
243
+ ChromaBlurRadius = 0xC631
244
+ AntiAliasStrength = 0xC632
245
+ ShadowScale = 0xC633
246
+ DNGPrivateData = 0xC634
247
+ MakerNoteSafety = 0xC635
248
+ CalibrationIlluminant1 = 0xC65A
249
+ CalibrationIlluminant2 = 0xC65B
250
+ BestQualityScale = 0xC65C
251
+ RawDataUniqueID = 0xC65D
252
+ OriginalRawFileName = 0xC68B
253
+ OriginalRawFileData = 0xC68C
254
+ ActiveArea = 0xC68D
255
+ MaskedAreas = 0xC68E
256
+ AsShotICCProfile = 0xC68F
257
+ AsShotPreProfileMatrix = 0xC690
258
+ CurrentICCProfile = 0xC691
259
+ CurrentPreProfileMatrix = 0xC692
260
+ ColorimetricReference = 0xC6BF
261
+ CameraCalibrationSignature = 0xC6F3
262
+ ProfileCalibrationSignature = 0xC6F4
263
+ AsShotProfileName = 0xC6F6
264
+ NoiseReductionApplied = 0xC6F7
265
+ ProfileName = 0xC6F8
266
+ ProfileHueSatMapDims = 0xC6F9
267
+ ProfileHueSatMapData1 = 0xC6FA
268
+ ProfileHueSatMapData2 = 0xC6FB
269
+ ProfileToneCurve = 0xC6FC
270
+ ProfileEmbedPolicy = 0xC6FD
271
+ ProfileCopyright = 0xC6FE
272
+ ForwardMatrix1 = 0xC714
273
+ ForwardMatrix2 = 0xC715
274
+ PreviewApplicationName = 0xC716
275
+ PreviewApplicationVersion = 0xC717
276
+ PreviewSettingsName = 0xC718
277
+ PreviewSettingsDigest = 0xC719
278
+ PreviewColorSpace = 0xC71A
279
+ PreviewDateTime = 0xC71B
280
+ RawImageDigest = 0xC71C
281
+ OriginalRawFileDigest = 0xC71D
282
+ SubTileBlockSize = 0xC71E
283
+ RowInterleaveFactor = 0xC71F
284
+ ProfileLookTableDims = 0xC725
285
+ ProfileLookTableData = 0xC726
286
+ OpcodeList1 = 0xC740
287
+ OpcodeList2 = 0xC741
288
+ OpcodeList3 = 0xC74E
289
+ NoiseProfile = 0xC761
290
+
291
+
292
+ """Maps EXIF tags to tag names."""
293
+ TAGS = {
294
+ **{i.value: i.name for i in Base},
295
+ 0x920C: "SpatialFrequencyResponse",
296
+ 0x9214: "SubjectLocation",
297
+ 0x9215: "ExposureIndex",
298
+ 0x828E: "CFAPattern",
299
+ 0x920B: "FlashEnergy",
300
+ 0x9216: "TIFF/EPStandardID",
301
+ }
302
+
303
+
304
+ class GPS(IntEnum):
305
+ GPSVersionID = 0
306
+ GPSLatitudeRef = 1
307
+ GPSLatitude = 2
308
+ GPSLongitudeRef = 3
309
+ GPSLongitude = 4
310
+ GPSAltitudeRef = 5
311
+ GPSAltitude = 6
312
+ GPSTimeStamp = 7
313
+ GPSSatellites = 8
314
+ GPSStatus = 9
315
+ GPSMeasureMode = 10
316
+ GPSDOP = 11
317
+ GPSSpeedRef = 12
318
+ GPSSpeed = 13
319
+ GPSTrackRef = 14
320
+ GPSTrack = 15
321
+ GPSImgDirectionRef = 16
322
+ GPSImgDirection = 17
323
+ GPSMapDatum = 18
324
+ GPSDestLatitudeRef = 19
325
+ GPSDestLatitude = 20
326
+ GPSDestLongitudeRef = 21
327
+ GPSDestLongitude = 22
328
+ GPSDestBearingRef = 23
329
+ GPSDestBearing = 24
330
+ GPSDestDistanceRef = 25
331
+ GPSDestDistance = 26
332
+ GPSProcessingMethod = 27
333
+ GPSAreaInformation = 28
334
+ GPSDateStamp = 29
335
+ GPSDifferential = 30
336
+ GPSHPositioningError = 31
337
+
338
+
339
+ """Maps EXIF GPS tags to tag names."""
340
+ GPSTAGS = {i.value: i.name for i in GPS}
341
+
342
+
343
+ class Interop(IntEnum):
344
+ InteropIndex = 1
345
+ InteropVersion = 2
346
+ RelatedImageFileFormat = 4096
347
+ RelatedImageWidth = 4097
348
+ RleatedImageHeight = 4098
349
+
350
+
351
+ class IFD(IntEnum):
352
+ Exif = 34665
353
+ GPSInfo = 34853
354
+ Makernote = 37500
355
+ Interop = 40965
356
+ IFD1 = -1
357
+
358
+
359
+ class LightSource(IntEnum):
360
+ Unknown = 0
361
+ Daylight = 1
362
+ Fluorescent = 2
363
+ Tungsten = 3
364
+ Flash = 4
365
+ Fine = 9
366
+ Cloudy = 10
367
+ Shade = 11
368
+ DaylightFluorescent = 12
369
+ DayWhiteFluorescent = 13
370
+ CoolWhiteFluorescent = 14
371
+ WhiteFluorescent = 15
372
+ StandardLightA = 17
373
+ StandardLightB = 18
374
+ StandardLightC = 19
375
+ D55 = 20
376
+ D65 = 21
377
+ D75 = 22
378
+ D50 = 23
379
+ ISO = 24
380
+ Other = 255
env/Lib/site-packages/PIL/FitsImagePlugin.py ADDED
@@ -0,0 +1,73 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library
3
+ # $Id$
4
+ #
5
+ # FITS file handling
6
+ #
7
+ # Copyright (c) 1998-2003 by Fredrik Lundh
8
+ #
9
+ # See the README file for information on usage and redistribution.
10
+ #
11
+
12
+ import math
13
+
14
+ from . import Image, ImageFile
15
+
16
+
17
+ def _accept(prefix):
18
+ return prefix[:6] == b"SIMPLE"
19
+
20
+
21
+ class FitsImageFile(ImageFile.ImageFile):
22
+ format = "FITS"
23
+ format_description = "FITS"
24
+
25
+ def _open(self):
26
+ headers = {}
27
+ while True:
28
+ header = self.fp.read(80)
29
+ if not header:
30
+ msg = "Truncated FITS file"
31
+ raise OSError(msg)
32
+ keyword = header[:8].strip()
33
+ if keyword == b"END":
34
+ break
35
+ value = header[8:].split(b"/")[0].strip()
36
+ if value.startswith(b"="):
37
+ value = value[1:].strip()
38
+ if not headers and (not _accept(keyword) or value != b"T"):
39
+ msg = "Not a FITS file"
40
+ raise SyntaxError(msg)
41
+ headers[keyword] = value
42
+
43
+ naxis = int(headers[b"NAXIS"])
44
+ if naxis == 0:
45
+ msg = "No image data"
46
+ raise ValueError(msg)
47
+ elif naxis == 1:
48
+ self._size = 1, int(headers[b"NAXIS1"])
49
+ else:
50
+ self._size = int(headers[b"NAXIS1"]), int(headers[b"NAXIS2"])
51
+
52
+ number_of_bits = int(headers[b"BITPIX"])
53
+ if number_of_bits == 8:
54
+ self._mode = "L"
55
+ elif number_of_bits == 16:
56
+ self._mode = "I"
57
+ # rawmode = "I;16S"
58
+ elif number_of_bits == 32:
59
+ self._mode = "I"
60
+ elif number_of_bits in (-32, -64):
61
+ self._mode = "F"
62
+ # rawmode = "F" if number_of_bits == -32 else "F;64F"
63
+
64
+ offset = math.ceil(self.fp.tell() / 2880) * 2880
65
+ self.tile = [("raw", (0, 0) + self.size, offset, (self.mode, 0, -1))]
66
+
67
+
68
+ # --------------------------------------------------------------------
69
+ # Registry
70
+
71
+ Image.register_open(FitsImageFile.format, FitsImageFile, _accept)
72
+
73
+ Image.register_extensions(FitsImageFile.format, [".fit", ".fits"])
env/Lib/site-packages/PIL/FliImagePlugin.py ADDED
@@ -0,0 +1,171 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library.
3
+ # $Id$
4
+ #
5
+ # FLI/FLC file handling.
6
+ #
7
+ # History:
8
+ # 95-09-01 fl Created
9
+ # 97-01-03 fl Fixed parser, setup decoder tile
10
+ # 98-07-15 fl Renamed offset attribute to avoid name clash
11
+ #
12
+ # Copyright (c) Secret Labs AB 1997-98.
13
+ # Copyright (c) Fredrik Lundh 1995-97.
14
+ #
15
+ # See the README file for information on usage and redistribution.
16
+ #
17
+
18
+ import os
19
+
20
+ from . import Image, ImageFile, ImagePalette
21
+ from ._binary import i16le as i16
22
+ from ._binary import i32le as i32
23
+ from ._binary import o8
24
+
25
+ #
26
+ # decoder
27
+
28
+
29
+ def _accept(prefix):
30
+ return (
31
+ len(prefix) >= 6
32
+ and i16(prefix, 4) in [0xAF11, 0xAF12]
33
+ and i16(prefix, 14) in [0, 3] # flags
34
+ )
35
+
36
+
37
+ ##
38
+ # Image plugin for the FLI/FLC animation format. Use the <b>seek</b>
39
+ # method to load individual frames.
40
+
41
+
42
+ class FliImageFile(ImageFile.ImageFile):
43
+ format = "FLI"
44
+ format_description = "Autodesk FLI/FLC Animation"
45
+ _close_exclusive_fp_after_loading = False
46
+
47
+ def _open(self):
48
+ # HEAD
49
+ s = self.fp.read(128)
50
+ if not (_accept(s) and s[20:22] == b"\x00\x00"):
51
+ msg = "not an FLI/FLC file"
52
+ raise SyntaxError(msg)
53
+
54
+ # frames
55
+ self.n_frames = i16(s, 6)
56
+ self.is_animated = self.n_frames > 1
57
+
58
+ # image characteristics
59
+ self._mode = "P"
60
+ self._size = i16(s, 8), i16(s, 10)
61
+
62
+ # animation speed
63
+ duration = i32(s, 16)
64
+ magic = i16(s, 4)
65
+ if magic == 0xAF11:
66
+ duration = (duration * 1000) // 70
67
+ self.info["duration"] = duration
68
+
69
+ # look for palette
70
+ palette = [(a, a, a) for a in range(256)]
71
+
72
+ s = self.fp.read(16)
73
+
74
+ self.__offset = 128
75
+
76
+ if i16(s, 4) == 0xF100:
77
+ # prefix chunk; ignore it
78
+ self.__offset = self.__offset + i32(s)
79
+ s = self.fp.read(16)
80
+
81
+ if i16(s, 4) == 0xF1FA:
82
+ # look for palette chunk
83
+ number_of_subchunks = i16(s, 6)
84
+ chunk_size = None
85
+ for _ in range(number_of_subchunks):
86
+ if chunk_size is not None:
87
+ self.fp.seek(chunk_size - 6, os.SEEK_CUR)
88
+ s = self.fp.read(6)
89
+ chunk_type = i16(s, 4)
90
+ if chunk_type in (4, 11):
91
+ self._palette(palette, 2 if chunk_type == 11 else 0)
92
+ break
93
+ chunk_size = i32(s)
94
+ if not chunk_size:
95
+ break
96
+
97
+ palette = [o8(r) + o8(g) + o8(b) for (r, g, b) in palette]
98
+ self.palette = ImagePalette.raw("RGB", b"".join(palette))
99
+
100
+ # set things up to decode first frame
101
+ self.__frame = -1
102
+ self._fp = self.fp
103
+ self.__rewind = self.fp.tell()
104
+ self.seek(0)
105
+
106
+ def _palette(self, palette, shift):
107
+ # load palette
108
+
109
+ i = 0
110
+ for e in range(i16(self.fp.read(2))):
111
+ s = self.fp.read(2)
112
+ i = i + s[0]
113
+ n = s[1]
114
+ if n == 0:
115
+ n = 256
116
+ s = self.fp.read(n * 3)
117
+ for n in range(0, len(s), 3):
118
+ r = s[n] << shift
119
+ g = s[n + 1] << shift
120
+ b = s[n + 2] << shift
121
+ palette[i] = (r, g, b)
122
+ i += 1
123
+
124
+ def seek(self, frame):
125
+ if not self._seek_check(frame):
126
+ return
127
+ if frame < self.__frame:
128
+ self._seek(0)
129
+
130
+ for f in range(self.__frame + 1, frame + 1):
131
+ self._seek(f)
132
+
133
+ def _seek(self, frame):
134
+ if frame == 0:
135
+ self.__frame = -1
136
+ self._fp.seek(self.__rewind)
137
+ self.__offset = 128
138
+ else:
139
+ # ensure that the previous frame was loaded
140
+ self.load()
141
+
142
+ if frame != self.__frame + 1:
143
+ msg = f"cannot seek to frame {frame}"
144
+ raise ValueError(msg)
145
+ self.__frame = frame
146
+
147
+ # move to next frame
148
+ self.fp = self._fp
149
+ self.fp.seek(self.__offset)
150
+
151
+ s = self.fp.read(4)
152
+ if not s:
153
+ raise EOFError
154
+
155
+ framesize = i32(s)
156
+
157
+ self.decodermaxblock = framesize
158
+ self.tile = [("fli", (0, 0) + self.size, self.__offset, None)]
159
+
160
+ self.__offset += framesize
161
+
162
+ def tell(self):
163
+ return self.__frame
164
+
165
+
166
+ #
167
+ # registry
168
+
169
+ Image.register_open(FliImageFile.format, FliImageFile, _accept)
170
+
171
+ Image.register_extensions(FliImageFile.format, [".fli", ".flc"])
env/Lib/site-packages/PIL/FontFile.py ADDED
@@ -0,0 +1,110 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library
3
+ # $Id$
4
+ #
5
+ # base class for raster font file parsers
6
+ #
7
+ # history:
8
+ # 1997-06-05 fl created
9
+ # 1997-08-19 fl restrict image width
10
+ #
11
+ # Copyright (c) 1997-1998 by Secret Labs AB
12
+ # Copyright (c) 1997-1998 by Fredrik Lundh
13
+ #
14
+ # See the README file for information on usage and redistribution.
15
+ #
16
+
17
+
18
+ import os
19
+
20
+ from . import Image, _binary
21
+
22
+ WIDTH = 800
23
+
24
+
25
+ def puti16(fp, values):
26
+ """Write network order (big-endian) 16-bit sequence"""
27
+ for v in values:
28
+ if v < 0:
29
+ v += 65536
30
+ fp.write(_binary.o16be(v))
31
+
32
+
33
+ class FontFile:
34
+ """Base class for raster font file handlers."""
35
+
36
+ bitmap = None
37
+
38
+ def __init__(self):
39
+ self.info = {}
40
+ self.glyph = [None] * 256
41
+
42
+ def __getitem__(self, ix):
43
+ return self.glyph[ix]
44
+
45
+ def compile(self):
46
+ """Create metrics and bitmap"""
47
+
48
+ if self.bitmap:
49
+ return
50
+
51
+ # create bitmap large enough to hold all data
52
+ h = w = maxwidth = 0
53
+ lines = 1
54
+ for glyph in self:
55
+ if glyph:
56
+ d, dst, src, im = glyph
57
+ h = max(h, src[3] - src[1])
58
+ w = w + (src[2] - src[0])
59
+ if w > WIDTH:
60
+ lines += 1
61
+ w = src[2] - src[0]
62
+ maxwidth = max(maxwidth, w)
63
+
64
+ xsize = maxwidth
65
+ ysize = lines * h
66
+
67
+ if xsize == 0 and ysize == 0:
68
+ return ""
69
+
70
+ self.ysize = h
71
+
72
+ # paste glyphs into bitmap
73
+ self.bitmap = Image.new("1", (xsize, ysize))
74
+ self.metrics = [None] * 256
75
+ x = y = 0
76
+ for i in range(256):
77
+ glyph = self[i]
78
+ if glyph:
79
+ d, dst, src, im = glyph
80
+ xx = src[2] - src[0]
81
+ # yy = src[3] - src[1]
82
+ x0, y0 = x, y
83
+ x = x + xx
84
+ if x > WIDTH:
85
+ x, y = 0, y + h
86
+ x0, y0 = x, y
87
+ x = xx
88
+ s = src[0] + x0, src[1] + y0, src[2] + x0, src[3] + y0
89
+ self.bitmap.paste(im.crop(src), s)
90
+ self.metrics[i] = d, dst, s
91
+
92
+ def save(self, filename):
93
+ """Save font"""
94
+
95
+ self.compile()
96
+
97
+ # font data
98
+ self.bitmap.save(os.path.splitext(filename)[0] + ".pbm", "PNG")
99
+
100
+ # font metrics
101
+ with open(os.path.splitext(filename)[0] + ".pil", "wb") as fp:
102
+ fp.write(b"PILfont\n")
103
+ fp.write(f";;;;;;{self.ysize};\n".encode("ascii")) # HACK!!!
104
+ fp.write(b"DATA\n")
105
+ for id in range(256):
106
+ m = self.metrics[id]
107
+ if not m:
108
+ puti16(fp, [0] * 10)
109
+ else:
110
+ puti16(fp, m[0] + m[1] + m[2])
env/Lib/site-packages/PIL/FpxImagePlugin.py ADDED
@@ -0,0 +1,253 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # THIS IS WORK IN PROGRESS
3
+ #
4
+ # The Python Imaging Library.
5
+ # $Id$
6
+ #
7
+ # FlashPix support for PIL
8
+ #
9
+ # History:
10
+ # 97-01-25 fl Created (reads uncompressed RGB images only)
11
+ #
12
+ # Copyright (c) Secret Labs AB 1997.
13
+ # Copyright (c) Fredrik Lundh 1997.
14
+ #
15
+ # See the README file for information on usage and redistribution.
16
+ #
17
+ import olefile
18
+
19
+ from . import Image, ImageFile
20
+ from ._binary import i32le as i32
21
+
22
+ # we map from colour field tuples to (mode, rawmode) descriptors
23
+ MODES = {
24
+ # opacity
25
+ (0x00007FFE,): ("A", "L"),
26
+ # monochrome
27
+ (0x00010000,): ("L", "L"),
28
+ (0x00018000, 0x00017FFE): ("RGBA", "LA"),
29
+ # photo YCC
30
+ (0x00020000, 0x00020001, 0x00020002): ("RGB", "YCC;P"),
31
+ (0x00028000, 0x00028001, 0x00028002, 0x00027FFE): ("RGBA", "YCCA;P"),
32
+ # standard RGB (NIFRGB)
33
+ (0x00030000, 0x00030001, 0x00030002): ("RGB", "RGB"),
34
+ (0x00038000, 0x00038001, 0x00038002, 0x00037FFE): ("RGBA", "RGBA"),
35
+ }
36
+
37
+
38
+ #
39
+ # --------------------------------------------------------------------
40
+
41
+
42
+ def _accept(prefix):
43
+ return prefix[:8] == olefile.MAGIC
44
+
45
+
46
+ ##
47
+ # Image plugin for the FlashPix images.
48
+
49
+
50
+ class FpxImageFile(ImageFile.ImageFile):
51
+ format = "FPX"
52
+ format_description = "FlashPix"
53
+
54
+ def _open(self):
55
+ #
56
+ # read the OLE directory and see if this is a likely
57
+ # to be a FlashPix file
58
+
59
+ try:
60
+ self.ole = olefile.OleFileIO(self.fp)
61
+ except OSError as e:
62
+ msg = "not an FPX file; invalid OLE file"
63
+ raise SyntaxError(msg) from e
64
+
65
+ if self.ole.root.clsid != "56616700-C154-11CE-8553-00AA00A1F95B":
66
+ msg = "not an FPX file; bad root CLSID"
67
+ raise SyntaxError(msg)
68
+
69
+ self._open_index(1)
70
+
71
+ def _open_index(self, index=1):
72
+ #
73
+ # get the Image Contents Property Set
74
+
75
+ prop = self.ole.getproperties(
76
+ [f"Data Object Store {index:06d}", "\005Image Contents"]
77
+ )
78
+
79
+ # size (highest resolution)
80
+
81
+ self._size = prop[0x1000002], prop[0x1000003]
82
+
83
+ size = max(self.size)
84
+ i = 1
85
+ while size > 64:
86
+ size = size / 2
87
+ i += 1
88
+ self.maxid = i - 1
89
+
90
+ # mode. instead of using a single field for this, flashpix
91
+ # requires you to specify the mode for each channel in each
92
+ # resolution subimage, and leaves it to the decoder to make
93
+ # sure that they all match. for now, we'll cheat and assume
94
+ # that this is always the case.
95
+
96
+ id = self.maxid << 16
97
+
98
+ s = prop[0x2000002 | id]
99
+
100
+ colors = []
101
+ bands = i32(s, 4)
102
+ if bands > 4:
103
+ msg = "Invalid number of bands"
104
+ raise OSError(msg)
105
+ for i in range(bands):
106
+ # note: for now, we ignore the "uncalibrated" flag
107
+ colors.append(i32(s, 8 + i * 4) & 0x7FFFFFFF)
108
+
109
+ self._mode, self.rawmode = MODES[tuple(colors)]
110
+
111
+ # load JPEG tables, if any
112
+ self.jpeg = {}
113
+ for i in range(256):
114
+ id = 0x3000001 | (i << 16)
115
+ if id in prop:
116
+ self.jpeg[i] = prop[id]
117
+
118
+ self._open_subimage(1, self.maxid)
119
+
120
+ def _open_subimage(self, index=1, subimage=0):
121
+ #
122
+ # setup tile descriptors for a given subimage
123
+
124
+ stream = [
125
+ f"Data Object Store {index:06d}",
126
+ f"Resolution {subimage:04d}",
127
+ "Subimage 0000 Header",
128
+ ]
129
+
130
+ fp = self.ole.openstream(stream)
131
+
132
+ # skip prefix
133
+ fp.read(28)
134
+
135
+ # header stream
136
+ s = fp.read(36)
137
+
138
+ size = i32(s, 4), i32(s, 8)
139
+ # tilecount = i32(s, 12)
140
+ tilesize = i32(s, 16), i32(s, 20)
141
+ # channels = i32(s, 24)
142
+ offset = i32(s, 28)
143
+ length = i32(s, 32)
144
+
145
+ if size != self.size:
146
+ msg = "subimage mismatch"
147
+ raise OSError(msg)
148
+
149
+ # get tile descriptors
150
+ fp.seek(28 + offset)
151
+ s = fp.read(i32(s, 12) * length)
152
+
153
+ x = y = 0
154
+ xsize, ysize = size
155
+ xtile, ytile = tilesize
156
+ self.tile = []
157
+
158
+ for i in range(0, len(s), length):
159
+ x1 = min(xsize, x + xtile)
160
+ y1 = min(ysize, y + ytile)
161
+
162
+ compression = i32(s, i + 8)
163
+
164
+ if compression == 0:
165
+ self.tile.append(
166
+ (
167
+ "raw",
168
+ (x, y, x1, y1),
169
+ i32(s, i) + 28,
170
+ (self.rawmode,),
171
+ )
172
+ )
173
+
174
+ elif compression == 1:
175
+ # FIXME: the fill decoder is not implemented
176
+ self.tile.append(
177
+ (
178
+ "fill",
179
+ (x, y, x1, y1),
180
+ i32(s, i) + 28,
181
+ (self.rawmode, s[12:16]),
182
+ )
183
+ )
184
+
185
+ elif compression == 2:
186
+ internal_color_conversion = s[14]
187
+ jpeg_tables = s[15]
188
+ rawmode = self.rawmode
189
+
190
+ if internal_color_conversion:
191
+ # The image is stored as usual (usually YCbCr).
192
+ if rawmode == "RGBA":
193
+ # For "RGBA", data is stored as YCbCrA based on
194
+ # negative RGB. The following trick works around
195
+ # this problem :
196
+ jpegmode, rawmode = "YCbCrK", "CMYK"
197
+ else:
198
+ jpegmode = None # let the decoder decide
199
+
200
+ else:
201
+ # The image is stored as defined by rawmode
202
+ jpegmode = rawmode
203
+
204
+ self.tile.append(
205
+ (
206
+ "jpeg",
207
+ (x, y, x1, y1),
208
+ i32(s, i) + 28,
209
+ (rawmode, jpegmode),
210
+ )
211
+ )
212
+
213
+ # FIXME: jpeg tables are tile dependent; the prefix
214
+ # data must be placed in the tile descriptor itself!
215
+
216
+ if jpeg_tables:
217
+ self.tile_prefix = self.jpeg[jpeg_tables]
218
+
219
+ else:
220
+ msg = "unknown/invalid compression"
221
+ raise OSError(msg)
222
+
223
+ x = x + xtile
224
+ if x >= xsize:
225
+ x, y = 0, y + ytile
226
+ if y >= ysize:
227
+ break # isn't really required
228
+
229
+ self.stream = stream
230
+ self.fp = None
231
+
232
+ def load(self):
233
+ if not self.fp:
234
+ self.fp = self.ole.openstream(self.stream[:2] + ["Subimage 0000 Data"])
235
+
236
+ return ImageFile.ImageFile.load(self)
237
+
238
+ def close(self):
239
+ self.ole.close()
240
+ super().close()
241
+
242
+ def __exit__(self, *args):
243
+ self.ole.close()
244
+ super().__exit__()
245
+
246
+
247
+ #
248
+ # --------------------------------------------------------------------
249
+
250
+
251
+ Image.register_open(FpxImageFile.format, FpxImageFile, _accept)
252
+
253
+ Image.register_extension(FpxImageFile.format, ".fpx")
env/Lib/site-packages/PIL/FtexImagePlugin.py ADDED
@@ -0,0 +1,113 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ A Pillow loader for .ftc and .ftu files (FTEX)
3
+ Jerome Leclanche <[email protected]>
4
+
5
+ The contents of this file are hereby released in the public domain (CC0)
6
+ Full text of the CC0 license:
7
+ https://creativecommons.org/publicdomain/zero/1.0/
8
+
9
+ Independence War 2: Edge Of Chaos - Texture File Format - 16 October 2001
10
+
11
+ The textures used for 3D objects in Independence War 2: Edge Of Chaos are in a
12
+ packed custom format called FTEX. This file format uses file extensions FTC
13
+ and FTU.
14
+ * FTC files are compressed textures (using standard texture compression).
15
+ * FTU files are not compressed.
16
+ Texture File Format
17
+ The FTC and FTU texture files both use the same format. This
18
+ has the following structure:
19
+ {header}
20
+ {format_directory}
21
+ {data}
22
+ Where:
23
+ {header} = {
24
+ u32:magic,
25
+ u32:version,
26
+ u32:width,
27
+ u32:height,
28
+ u32:mipmap_count,
29
+ u32:format_count
30
+ }
31
+
32
+ * The "magic" number is "FTEX".
33
+ * "width" and "height" are the dimensions of the texture.
34
+ * "mipmap_count" is the number of mipmaps in the texture.
35
+ * "format_count" is the number of texture formats (different versions of the
36
+ same texture) in this file.
37
+
38
+ {format_directory} = format_count * { u32:format, u32:where }
39
+
40
+ The format value is 0 for DXT1 compressed textures and 1 for 24-bit RGB
41
+ uncompressed textures.
42
+ The texture data for a format starts at the position "where" in the file.
43
+
44
+ Each set of texture data in the file has the following structure:
45
+ {data} = format_count * { u32:mipmap_size, mipmap_size * { u8 } }
46
+ * "mipmap_size" is the number of bytes in that mip level. For compressed
47
+ textures this is the size of the texture data compressed with DXT1. For 24 bit
48
+ uncompressed textures, this is 3 * width * height. Following this are the image
49
+ bytes for that mipmap level.
50
+
51
+ Note: All data is stored in little-Endian (Intel) byte order.
52
+ """
53
+
54
+ import struct
55
+ from enum import IntEnum
56
+ from io import BytesIO
57
+
58
+ from . import Image, ImageFile
59
+
60
+ MAGIC = b"FTEX"
61
+
62
+
63
+ class Format(IntEnum):
64
+ DXT1 = 0
65
+ UNCOMPRESSED = 1
66
+
67
+
68
+ class FtexImageFile(ImageFile.ImageFile):
69
+ format = "FTEX"
70
+ format_description = "Texture File Format (IW2:EOC)"
71
+
72
+ def _open(self):
73
+ if not _accept(self.fp.read(4)):
74
+ msg = "not an FTEX file"
75
+ raise SyntaxError(msg)
76
+ struct.unpack("<i", self.fp.read(4)) # version
77
+ self._size = struct.unpack("<2i", self.fp.read(8))
78
+ mipmap_count, format_count = struct.unpack("<2i", self.fp.read(8))
79
+
80
+ self._mode = "RGB"
81
+
82
+ # Only support single-format files.
83
+ # I don't know of any multi-format file.
84
+ assert format_count == 1
85
+
86
+ format, where = struct.unpack("<2i", self.fp.read(8))
87
+ self.fp.seek(where)
88
+ (mipmap_size,) = struct.unpack("<i", self.fp.read(4))
89
+
90
+ data = self.fp.read(mipmap_size)
91
+
92
+ if format == Format.DXT1:
93
+ self._mode = "RGBA"
94
+ self.tile = [("bcn", (0, 0) + self.size, 0, 1)]
95
+ elif format == Format.UNCOMPRESSED:
96
+ self.tile = [("raw", (0, 0) + self.size, 0, ("RGB", 0, 1))]
97
+ else:
98
+ msg = f"Invalid texture compression format: {repr(format)}"
99
+ raise ValueError(msg)
100
+
101
+ self.fp.close()
102
+ self.fp = BytesIO(data)
103
+
104
+ def load_seek(self, pos):
105
+ pass
106
+
107
+
108
+ def _accept(prefix):
109
+ return prefix[:4] == MAGIC
110
+
111
+
112
+ Image.register_open(FtexImageFile.format, FtexImageFile, _accept)
113
+ Image.register_extensions(FtexImageFile.format, [".ftc", ".ftu"])
env/Lib/site-packages/PIL/GbrImagePlugin.py ADDED
@@ -0,0 +1,102 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library
3
+ #
4
+ # load a GIMP brush file
5
+ #
6
+ # History:
7
+ # 96-03-14 fl Created
8
+ # 16-01-08 es Version 2
9
+ #
10
+ # Copyright (c) Secret Labs AB 1997.
11
+ # Copyright (c) Fredrik Lundh 1996.
12
+ # Copyright (c) Eric Soroos 2016.
13
+ #
14
+ # See the README file for information on usage and redistribution.
15
+ #
16
+ #
17
+ # See https://github.com/GNOME/gimp/blob/mainline/devel-docs/gbr.txt for
18
+ # format documentation.
19
+ #
20
+ # This code Interprets version 1 and 2 .gbr files.
21
+ # Version 1 files are obsolete, and should not be used for new
22
+ # brushes.
23
+ # Version 2 files are saved by GIMP v2.8 (at least)
24
+ # Version 3 files have a format specifier of 18 for 16bit floats in
25
+ # the color depth field. This is currently unsupported by Pillow.
26
+
27
+ from . import Image, ImageFile
28
+ from ._binary import i32be as i32
29
+
30
+
31
+ def _accept(prefix):
32
+ return len(prefix) >= 8 and i32(prefix, 0) >= 20 and i32(prefix, 4) in (1, 2)
33
+
34
+
35
+ ##
36
+ # Image plugin for the GIMP brush format.
37
+
38
+
39
+ class GbrImageFile(ImageFile.ImageFile):
40
+ format = "GBR"
41
+ format_description = "GIMP brush file"
42
+
43
+ def _open(self):
44
+ header_size = i32(self.fp.read(4))
45
+ if header_size < 20:
46
+ msg = "not a GIMP brush"
47
+ raise SyntaxError(msg)
48
+ version = i32(self.fp.read(4))
49
+ if version not in (1, 2):
50
+ msg = f"Unsupported GIMP brush version: {version}"
51
+ raise SyntaxError(msg)
52
+
53
+ width = i32(self.fp.read(4))
54
+ height = i32(self.fp.read(4))
55
+ color_depth = i32(self.fp.read(4))
56
+ if width <= 0 or height <= 0:
57
+ msg = "not a GIMP brush"
58
+ raise SyntaxError(msg)
59
+ if color_depth not in (1, 4):
60
+ msg = f"Unsupported GIMP brush color depth: {color_depth}"
61
+ raise SyntaxError(msg)
62
+
63
+ if version == 1:
64
+ comment_length = header_size - 20
65
+ else:
66
+ comment_length = header_size - 28
67
+ magic_number = self.fp.read(4)
68
+ if magic_number != b"GIMP":
69
+ msg = "not a GIMP brush, bad magic number"
70
+ raise SyntaxError(msg)
71
+ self.info["spacing"] = i32(self.fp.read(4))
72
+
73
+ comment = self.fp.read(comment_length)[:-1]
74
+
75
+ if color_depth == 1:
76
+ self._mode = "L"
77
+ else:
78
+ self._mode = "RGBA"
79
+
80
+ self._size = width, height
81
+
82
+ self.info["comment"] = comment
83
+
84
+ # Image might not be small
85
+ Image._decompression_bomb_check(self.size)
86
+
87
+ # Data is an uncompressed block of w * h * bytes/pixel
88
+ self._data_size = width * height * color_depth
89
+
90
+ def load(self):
91
+ if not self.im:
92
+ self.im = Image.core.new(self.mode, self.size)
93
+ self.frombytes(self.fp.read(self._data_size))
94
+ return Image.Image.load(self)
95
+
96
+
97
+ #
98
+ # registry
99
+
100
+
101
+ Image.register_open(GbrImageFile.format, GbrImageFile, _accept)
102
+ Image.register_extension(GbrImageFile.format, ".gbr")
env/Lib/site-packages/PIL/GdImageFile.py ADDED
@@ -0,0 +1,97 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library.
3
+ # $Id$
4
+ #
5
+ # GD file handling
6
+ #
7
+ # History:
8
+ # 1996-04-12 fl Created
9
+ #
10
+ # Copyright (c) 1997 by Secret Labs AB.
11
+ # Copyright (c) 1996 by Fredrik Lundh.
12
+ #
13
+ # See the README file for information on usage and redistribution.
14
+ #
15
+
16
+
17
+ """
18
+ .. note::
19
+ This format cannot be automatically recognized, so the
20
+ class is not registered for use with :py:func:`PIL.Image.open()`. To open a
21
+ gd file, use the :py:func:`PIL.GdImageFile.open()` function instead.
22
+
23
+ .. warning::
24
+ THE GD FORMAT IS NOT DESIGNED FOR DATA INTERCHANGE. This
25
+ implementation is provided for convenience and demonstrational
26
+ purposes only.
27
+ """
28
+
29
+
30
+ from . import ImageFile, ImagePalette, UnidentifiedImageError
31
+ from ._binary import i16be as i16
32
+ from ._binary import i32be as i32
33
+
34
+
35
+ class GdImageFile(ImageFile.ImageFile):
36
+ """
37
+ Image plugin for the GD uncompressed format. Note that this format
38
+ is not supported by the standard :py:func:`PIL.Image.open()` function. To use
39
+ this plugin, you have to import the :py:mod:`PIL.GdImageFile` module and
40
+ use the :py:func:`PIL.GdImageFile.open()` function.
41
+ """
42
+
43
+ format = "GD"
44
+ format_description = "GD uncompressed images"
45
+
46
+ def _open(self):
47
+ # Header
48
+ s = self.fp.read(1037)
49
+
50
+ if i16(s) not in [65534, 65535]:
51
+ msg = "Not a valid GD 2.x .gd file"
52
+ raise SyntaxError(msg)
53
+
54
+ self._mode = "L" # FIXME: "P"
55
+ self._size = i16(s, 2), i16(s, 4)
56
+
57
+ true_color = s[6]
58
+ true_color_offset = 2 if true_color else 0
59
+
60
+ # transparency index
61
+ tindex = i32(s, 7 + true_color_offset)
62
+ if tindex < 256:
63
+ self.info["transparency"] = tindex
64
+
65
+ self.palette = ImagePalette.raw(
66
+ "XBGR", s[7 + true_color_offset + 4 : 7 + true_color_offset + 4 + 256 * 4]
67
+ )
68
+
69
+ self.tile = [
70
+ (
71
+ "raw",
72
+ (0, 0) + self.size,
73
+ 7 + true_color_offset + 4 + 256 * 4,
74
+ ("L", 0, 1),
75
+ )
76
+ ]
77
+
78
+
79
+ def open(fp, mode="r"):
80
+ """
81
+ Load texture from a GD image file.
82
+
83
+ :param fp: GD file name, or an opened file handle.
84
+ :param mode: Optional mode. In this version, if the mode argument
85
+ is given, it must be "r".
86
+ :returns: An image instance.
87
+ :raises OSError: If the image could not be read.
88
+ """
89
+ if mode != "r":
90
+ msg = "bad mode"
91
+ raise ValueError(msg)
92
+
93
+ try:
94
+ return GdImageFile(fp)
95
+ except SyntaxError as e:
96
+ msg = "cannot identify this image file"
97
+ raise UnidentifiedImageError(msg) from e
env/Lib/site-packages/PIL/GifImagePlugin.py ADDED
@@ -0,0 +1,1060 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library.
3
+ # $Id$
4
+ #
5
+ # GIF file handling
6
+ #
7
+ # History:
8
+ # 1995-09-01 fl Created
9
+ # 1996-12-14 fl Added interlace support
10
+ # 1996-12-30 fl Added animation support
11
+ # 1997-01-05 fl Added write support, fixed local colour map bug
12
+ # 1997-02-23 fl Make sure to load raster data in getdata()
13
+ # 1997-07-05 fl Support external decoder (0.4)
14
+ # 1998-07-09 fl Handle all modes when saving (0.5)
15
+ # 1998-07-15 fl Renamed offset attribute to avoid name clash
16
+ # 2001-04-16 fl Added rewind support (seek to frame 0) (0.6)
17
+ # 2001-04-17 fl Added palette optimization (0.7)
18
+ # 2002-06-06 fl Added transparency support for save (0.8)
19
+ # 2004-02-24 fl Disable interlacing for small images
20
+ #
21
+ # Copyright (c) 1997-2004 by Secret Labs AB
22
+ # Copyright (c) 1995-2004 by Fredrik Lundh
23
+ #
24
+ # See the README file for information on usage and redistribution.
25
+ #
26
+
27
+ import itertools
28
+ import math
29
+ import os
30
+ import subprocess
31
+ from enum import IntEnum
32
+
33
+ from . import Image, ImageChops, ImageFile, ImagePalette, ImageSequence
34
+ from ._binary import i16le as i16
35
+ from ._binary import o8
36
+ from ._binary import o16le as o16
37
+
38
+
39
+ class LoadingStrategy(IntEnum):
40
+ """.. versionadded:: 9.1.0"""
41
+
42
+ RGB_AFTER_FIRST = 0
43
+ RGB_AFTER_DIFFERENT_PALETTE_ONLY = 1
44
+ RGB_ALWAYS = 2
45
+
46
+
47
+ #: .. versionadded:: 9.1.0
48
+ LOADING_STRATEGY = LoadingStrategy.RGB_AFTER_FIRST
49
+
50
+ # --------------------------------------------------------------------
51
+ # Identify/read GIF files
52
+
53
+
54
+ def _accept(prefix):
55
+ return prefix[:6] in [b"GIF87a", b"GIF89a"]
56
+
57
+
58
+ ##
59
+ # Image plugin for GIF images. This plugin supports both GIF87 and
60
+ # GIF89 images.
61
+
62
+
63
+ class GifImageFile(ImageFile.ImageFile):
64
+ format = "GIF"
65
+ format_description = "Compuserve GIF"
66
+ _close_exclusive_fp_after_loading = False
67
+
68
+ global_palette = None
69
+
70
+ def data(self):
71
+ s = self.fp.read(1)
72
+ if s and s[0]:
73
+ return self.fp.read(s[0])
74
+ return None
75
+
76
+ def _is_palette_needed(self, p):
77
+ for i in range(0, len(p), 3):
78
+ if not (i // 3 == p[i] == p[i + 1] == p[i + 2]):
79
+ return True
80
+ return False
81
+
82
+ def _open(self):
83
+ # Screen
84
+ s = self.fp.read(13)
85
+ if not _accept(s):
86
+ msg = "not a GIF file"
87
+ raise SyntaxError(msg)
88
+
89
+ self.info["version"] = s[:6]
90
+ self._size = i16(s, 6), i16(s, 8)
91
+ self.tile = []
92
+ flags = s[10]
93
+ bits = (flags & 7) + 1
94
+
95
+ if flags & 128:
96
+ # get global palette
97
+ self.info["background"] = s[11]
98
+ # check if palette contains colour indices
99
+ p = self.fp.read(3 << bits)
100
+ if self._is_palette_needed(p):
101
+ p = ImagePalette.raw("RGB", p)
102
+ self.global_palette = self.palette = p
103
+
104
+ self._fp = self.fp # FIXME: hack
105
+ self.__rewind = self.fp.tell()
106
+ self._n_frames = None
107
+ self._is_animated = None
108
+ self._seek(0) # get ready to read first frame
109
+
110
+ @property
111
+ def n_frames(self):
112
+ if self._n_frames is None:
113
+ current = self.tell()
114
+ try:
115
+ while True:
116
+ self._seek(self.tell() + 1, False)
117
+ except EOFError:
118
+ self._n_frames = self.tell() + 1
119
+ self.seek(current)
120
+ return self._n_frames
121
+
122
+ @property
123
+ def is_animated(self):
124
+ if self._is_animated is None:
125
+ if self._n_frames is not None:
126
+ self._is_animated = self._n_frames != 1
127
+ else:
128
+ current = self.tell()
129
+ if current:
130
+ self._is_animated = True
131
+ else:
132
+ try:
133
+ self._seek(1, False)
134
+ self._is_animated = True
135
+ except EOFError:
136
+ self._is_animated = False
137
+
138
+ self.seek(current)
139
+ return self._is_animated
140
+
141
+ def seek(self, frame):
142
+ if not self._seek_check(frame):
143
+ return
144
+ if frame < self.__frame:
145
+ self.im = None
146
+ self._seek(0)
147
+
148
+ last_frame = self.__frame
149
+ for f in range(self.__frame + 1, frame + 1):
150
+ try:
151
+ self._seek(f)
152
+ except EOFError as e:
153
+ self.seek(last_frame)
154
+ msg = "no more images in GIF file"
155
+ raise EOFError(msg) from e
156
+
157
+ def _seek(self, frame, update_image=True):
158
+ if frame == 0:
159
+ # rewind
160
+ self.__offset = 0
161
+ self.dispose = None
162
+ self.__frame = -1
163
+ self._fp.seek(self.__rewind)
164
+ self.disposal_method = 0
165
+ if "comment" in self.info:
166
+ del self.info["comment"]
167
+ else:
168
+ # ensure that the previous frame was loaded
169
+ if self.tile and update_image:
170
+ self.load()
171
+
172
+ if frame != self.__frame + 1:
173
+ msg = f"cannot seek to frame {frame}"
174
+ raise ValueError(msg)
175
+
176
+ self.fp = self._fp
177
+ if self.__offset:
178
+ # backup to last frame
179
+ self.fp.seek(self.__offset)
180
+ while self.data():
181
+ pass
182
+ self.__offset = 0
183
+
184
+ s = self.fp.read(1)
185
+ if not s or s == b";":
186
+ raise EOFError
187
+
188
+ palette = None
189
+
190
+ info = {}
191
+ frame_transparency = None
192
+ interlace = None
193
+ frame_dispose_extent = None
194
+ while True:
195
+ if not s:
196
+ s = self.fp.read(1)
197
+ if not s or s == b";":
198
+ break
199
+
200
+ elif s == b"!":
201
+ #
202
+ # extensions
203
+ #
204
+ s = self.fp.read(1)
205
+ block = self.data()
206
+ if s[0] == 249:
207
+ #
208
+ # graphic control extension
209
+ #
210
+ flags = block[0]
211
+ if flags & 1:
212
+ frame_transparency = block[3]
213
+ info["duration"] = i16(block, 1) * 10
214
+
215
+ # disposal method - find the value of bits 4 - 6
216
+ dispose_bits = 0b00011100 & flags
217
+ dispose_bits = dispose_bits >> 2
218
+ if dispose_bits:
219
+ # only set the dispose if it is not
220
+ # unspecified. I'm not sure if this is
221
+ # correct, but it seems to prevent the last
222
+ # frame from looking odd for some animations
223
+ self.disposal_method = dispose_bits
224
+ elif s[0] == 254:
225
+ #
226
+ # comment extension
227
+ #
228
+ comment = b""
229
+
230
+ # Read this comment block
231
+ while block:
232
+ comment += block
233
+ block = self.data()
234
+
235
+ if "comment" in info:
236
+ # If multiple comment blocks in frame, separate with \n
237
+ info["comment"] += b"\n" + comment
238
+ else:
239
+ info["comment"] = comment
240
+ s = None
241
+ continue
242
+ elif s[0] == 255 and frame == 0:
243
+ #
244
+ # application extension
245
+ #
246
+ info["extension"] = block, self.fp.tell()
247
+ if block[:11] == b"NETSCAPE2.0":
248
+ block = self.data()
249
+ if len(block) >= 3 and block[0] == 1:
250
+ self.info["loop"] = i16(block, 1)
251
+ while self.data():
252
+ pass
253
+
254
+ elif s == b",":
255
+ #
256
+ # local image
257
+ #
258
+ s = self.fp.read(9)
259
+
260
+ # extent
261
+ x0, y0 = i16(s, 0), i16(s, 2)
262
+ x1, y1 = x0 + i16(s, 4), y0 + i16(s, 6)
263
+ if (x1 > self.size[0] or y1 > self.size[1]) and update_image:
264
+ self._size = max(x1, self.size[0]), max(y1, self.size[1])
265
+ Image._decompression_bomb_check(self._size)
266
+ frame_dispose_extent = x0, y0, x1, y1
267
+ flags = s[8]
268
+
269
+ interlace = (flags & 64) != 0
270
+
271
+ if flags & 128:
272
+ bits = (flags & 7) + 1
273
+ p = self.fp.read(3 << bits)
274
+ if self._is_palette_needed(p):
275
+ palette = ImagePalette.raw("RGB", p)
276
+ else:
277
+ palette = False
278
+
279
+ # image data
280
+ bits = self.fp.read(1)[0]
281
+ self.__offset = self.fp.tell()
282
+ break
283
+
284
+ else:
285
+ pass
286
+ # raise OSError, "illegal GIF tag `%x`" % s[0]
287
+ s = None
288
+
289
+ if interlace is None:
290
+ # self._fp = None
291
+ raise EOFError
292
+
293
+ self.__frame = frame
294
+ if not update_image:
295
+ return
296
+
297
+ self.tile = []
298
+
299
+ if self.dispose:
300
+ self.im.paste(self.dispose, self.dispose_extent)
301
+
302
+ self._frame_palette = palette if palette is not None else self.global_palette
303
+ self._frame_transparency = frame_transparency
304
+ if frame == 0:
305
+ if self._frame_palette:
306
+ if LOADING_STRATEGY == LoadingStrategy.RGB_ALWAYS:
307
+ self._mode = "RGBA" if frame_transparency is not None else "RGB"
308
+ else:
309
+ self._mode = "P"
310
+ else:
311
+ self._mode = "L"
312
+
313
+ if not palette and self.global_palette:
314
+ from copy import copy
315
+
316
+ palette = copy(self.global_palette)
317
+ self.palette = palette
318
+ else:
319
+ if self.mode == "P":
320
+ if (
321
+ LOADING_STRATEGY != LoadingStrategy.RGB_AFTER_DIFFERENT_PALETTE_ONLY
322
+ or palette
323
+ ):
324
+ self.pyaccess = None
325
+ if "transparency" in self.info:
326
+ self.im.putpalettealpha(self.info["transparency"], 0)
327
+ self.im = self.im.convert("RGBA", Image.Dither.FLOYDSTEINBERG)
328
+ self._mode = "RGBA"
329
+ del self.info["transparency"]
330
+ else:
331
+ self._mode = "RGB"
332
+ self.im = self.im.convert("RGB", Image.Dither.FLOYDSTEINBERG)
333
+
334
+ def _rgb(color):
335
+ if self._frame_palette:
336
+ color = tuple(self._frame_palette.palette[color * 3 : color * 3 + 3])
337
+ else:
338
+ color = (color, color, color)
339
+ return color
340
+
341
+ self.dispose_extent = frame_dispose_extent
342
+ try:
343
+ if self.disposal_method < 2:
344
+ # do not dispose or none specified
345
+ self.dispose = None
346
+ elif self.disposal_method == 2:
347
+ # replace with background colour
348
+
349
+ # only dispose the extent in this frame
350
+ x0, y0, x1, y1 = self.dispose_extent
351
+ dispose_size = (x1 - x0, y1 - y0)
352
+
353
+ Image._decompression_bomb_check(dispose_size)
354
+
355
+ # by convention, attempt to use transparency first
356
+ dispose_mode = "P"
357
+ color = self.info.get("transparency", frame_transparency)
358
+ if color is not None:
359
+ if self.mode in ("RGB", "RGBA"):
360
+ dispose_mode = "RGBA"
361
+ color = _rgb(color) + (0,)
362
+ else:
363
+ color = self.info.get("background", 0)
364
+ if self.mode in ("RGB", "RGBA"):
365
+ dispose_mode = "RGB"
366
+ color = _rgb(color)
367
+ self.dispose = Image.core.fill(dispose_mode, dispose_size, color)
368
+ else:
369
+ # replace with previous contents
370
+ if self.im is not None:
371
+ # only dispose the extent in this frame
372
+ self.dispose = self._crop(self.im, self.dispose_extent)
373
+ elif frame_transparency is not None:
374
+ x0, y0, x1, y1 = self.dispose_extent
375
+ dispose_size = (x1 - x0, y1 - y0)
376
+
377
+ Image._decompression_bomb_check(dispose_size)
378
+ dispose_mode = "P"
379
+ color = frame_transparency
380
+ if self.mode in ("RGB", "RGBA"):
381
+ dispose_mode = "RGBA"
382
+ color = _rgb(frame_transparency) + (0,)
383
+ self.dispose = Image.core.fill(dispose_mode, dispose_size, color)
384
+ except AttributeError:
385
+ pass
386
+
387
+ if interlace is not None:
388
+ transparency = -1
389
+ if frame_transparency is not None:
390
+ if frame == 0:
391
+ if LOADING_STRATEGY != LoadingStrategy.RGB_ALWAYS:
392
+ self.info["transparency"] = frame_transparency
393
+ elif self.mode not in ("RGB", "RGBA"):
394
+ transparency = frame_transparency
395
+ self.tile = [
396
+ (
397
+ "gif",
398
+ (x0, y0, x1, y1),
399
+ self.__offset,
400
+ (bits, interlace, transparency),
401
+ )
402
+ ]
403
+
404
+ if info.get("comment"):
405
+ self.info["comment"] = info["comment"]
406
+ for k in ["duration", "extension"]:
407
+ if k in info:
408
+ self.info[k] = info[k]
409
+ elif k in self.info:
410
+ del self.info[k]
411
+
412
+ def load_prepare(self):
413
+ temp_mode = "P" if self._frame_palette else "L"
414
+ self._prev_im = None
415
+ if self.__frame == 0:
416
+ if self._frame_transparency is not None:
417
+ self.im = Image.core.fill(
418
+ temp_mode, self.size, self._frame_transparency
419
+ )
420
+ elif self.mode in ("RGB", "RGBA"):
421
+ self._prev_im = self.im
422
+ if self._frame_palette:
423
+ self.im = Image.core.fill("P", self.size, self._frame_transparency or 0)
424
+ self.im.putpalette(*self._frame_palette.getdata())
425
+ else:
426
+ self.im = None
427
+ self._mode = temp_mode
428
+ self._frame_palette = None
429
+
430
+ super().load_prepare()
431
+
432
+ def load_end(self):
433
+ if self.__frame == 0:
434
+ if self.mode == "P" and LOADING_STRATEGY == LoadingStrategy.RGB_ALWAYS:
435
+ if self._frame_transparency is not None:
436
+ self.im.putpalettealpha(self._frame_transparency, 0)
437
+ self._mode = "RGBA"
438
+ else:
439
+ self._mode = "RGB"
440
+ self.im = self.im.convert(self.mode, Image.Dither.FLOYDSTEINBERG)
441
+ return
442
+ if not self._prev_im:
443
+ return
444
+ if self._frame_transparency is not None:
445
+ self.im.putpalettealpha(self._frame_transparency, 0)
446
+ frame_im = self.im.convert("RGBA")
447
+ else:
448
+ frame_im = self.im.convert("RGB")
449
+ frame_im = self._crop(frame_im, self.dispose_extent)
450
+
451
+ self.im = self._prev_im
452
+ self._mode = self.im.mode
453
+ if frame_im.mode == "RGBA":
454
+ self.im.paste(frame_im, self.dispose_extent, frame_im)
455
+ else:
456
+ self.im.paste(frame_im, self.dispose_extent)
457
+
458
+ def tell(self):
459
+ return self.__frame
460
+
461
+
462
+ # --------------------------------------------------------------------
463
+ # Write GIF files
464
+
465
+
466
+ RAWMODE = {"1": "L", "L": "L", "P": "P"}
467
+
468
+
469
+ def _normalize_mode(im):
470
+ """
471
+ Takes an image (or frame), returns an image in a mode that is appropriate
472
+ for saving in a Gif.
473
+
474
+ It may return the original image, or it may return an image converted to
475
+ palette or 'L' mode.
476
+
477
+ :param im: Image object
478
+ :returns: Image object
479
+ """
480
+ if im.mode in RAWMODE:
481
+ im.load()
482
+ return im
483
+ if Image.getmodebase(im.mode) == "RGB":
484
+ im = im.convert("P", palette=Image.Palette.ADAPTIVE)
485
+ if im.palette.mode == "RGBA":
486
+ for rgba in im.palette.colors:
487
+ if rgba[3] == 0:
488
+ im.info["transparency"] = im.palette.colors[rgba]
489
+ break
490
+ return im
491
+ return im.convert("L")
492
+
493
+
494
+ def _normalize_palette(im, palette, info):
495
+ """
496
+ Normalizes the palette for image.
497
+ - Sets the palette to the incoming palette, if provided.
498
+ - Ensures that there's a palette for L mode images
499
+ - Optimizes the palette if necessary/desired.
500
+
501
+ :param im: Image object
502
+ :param palette: bytes object containing the source palette, or ....
503
+ :param info: encoderinfo
504
+ :returns: Image object
505
+ """
506
+ source_palette = None
507
+ if palette:
508
+ # a bytes palette
509
+ if isinstance(palette, (bytes, bytearray, list)):
510
+ source_palette = bytearray(palette[:768])
511
+ if isinstance(palette, ImagePalette.ImagePalette):
512
+ source_palette = bytearray(palette.palette)
513
+
514
+ if im.mode == "P":
515
+ if not source_palette:
516
+ source_palette = im.im.getpalette("RGB")[:768]
517
+ else: # L-mode
518
+ if not source_palette:
519
+ source_palette = bytearray(i // 3 for i in range(768))
520
+ im.palette = ImagePalette.ImagePalette("RGB", palette=source_palette)
521
+
522
+ if palette:
523
+ used_palette_colors = []
524
+ for i in range(0, len(source_palette), 3):
525
+ source_color = tuple(source_palette[i : i + 3])
526
+ index = im.palette.colors.get(source_color)
527
+ if index in used_palette_colors:
528
+ index = None
529
+ used_palette_colors.append(index)
530
+ for i, index in enumerate(used_palette_colors):
531
+ if index is None:
532
+ for j in range(len(used_palette_colors)):
533
+ if j not in used_palette_colors:
534
+ used_palette_colors[i] = j
535
+ break
536
+ im = im.remap_palette(used_palette_colors)
537
+ else:
538
+ used_palette_colors = _get_optimize(im, info)
539
+ if used_palette_colors is not None:
540
+ return im.remap_palette(used_palette_colors, source_palette)
541
+
542
+ im.palette.palette = source_palette
543
+ return im
544
+
545
+
546
+ def _write_single_frame(im, fp, palette):
547
+ im_out = _normalize_mode(im)
548
+ for k, v in im_out.info.items():
549
+ im.encoderinfo.setdefault(k, v)
550
+ im_out = _normalize_palette(im_out, palette, im.encoderinfo)
551
+
552
+ for s in _get_global_header(im_out, im.encoderinfo):
553
+ fp.write(s)
554
+
555
+ # local image header
556
+ flags = 0
557
+ if get_interlace(im):
558
+ flags = flags | 64
559
+ _write_local_header(fp, im, (0, 0), flags)
560
+
561
+ im_out.encoderconfig = (8, get_interlace(im))
562
+ ImageFile._save(im_out, fp, [("gif", (0, 0) + im.size, 0, RAWMODE[im_out.mode])])
563
+
564
+ fp.write(b"\0") # end of image data
565
+
566
+
567
+ def _getbbox(base_im, im_frame):
568
+ if _get_palette_bytes(im_frame) == _get_palette_bytes(base_im):
569
+ delta = ImageChops.subtract_modulo(im_frame, base_im)
570
+ else:
571
+ delta = ImageChops.subtract_modulo(
572
+ im_frame.convert("RGBA"), base_im.convert("RGBA")
573
+ )
574
+ return delta.getbbox(alpha_only=False)
575
+
576
+
577
+ def _write_multiple_frames(im, fp, palette):
578
+ duration = im.encoderinfo.get("duration")
579
+ disposal = im.encoderinfo.get("disposal", im.info.get("disposal"))
580
+
581
+ im_frames = []
582
+ frame_count = 0
583
+ background_im = None
584
+ for imSequence in itertools.chain([im], im.encoderinfo.get("append_images", [])):
585
+ for im_frame in ImageSequence.Iterator(imSequence):
586
+ # a copy is required here since seek can still mutate the image
587
+ im_frame = _normalize_mode(im_frame.copy())
588
+ if frame_count == 0:
589
+ for k, v in im_frame.info.items():
590
+ if k == "transparency":
591
+ continue
592
+ im.encoderinfo.setdefault(k, v)
593
+
594
+ encoderinfo = im.encoderinfo.copy()
595
+ im_frame = _normalize_palette(im_frame, palette, encoderinfo)
596
+ if "transparency" in im_frame.info:
597
+ encoderinfo.setdefault("transparency", im_frame.info["transparency"])
598
+ if isinstance(duration, (list, tuple)):
599
+ encoderinfo["duration"] = duration[frame_count]
600
+ elif duration is None and "duration" in im_frame.info:
601
+ encoderinfo["duration"] = im_frame.info["duration"]
602
+ if isinstance(disposal, (list, tuple)):
603
+ encoderinfo["disposal"] = disposal[frame_count]
604
+ frame_count += 1
605
+
606
+ if im_frames:
607
+ # delta frame
608
+ previous = im_frames[-1]
609
+ bbox = _getbbox(previous["im"], im_frame)
610
+ if not bbox:
611
+ # This frame is identical to the previous frame
612
+ if encoderinfo.get("duration"):
613
+ previous["encoderinfo"]["duration"] += encoderinfo["duration"]
614
+ continue
615
+ if encoderinfo.get("disposal") == 2:
616
+ if background_im is None:
617
+ color = im.encoderinfo.get(
618
+ "transparency", im.info.get("transparency", (0, 0, 0))
619
+ )
620
+ background = _get_background(im_frame, color)
621
+ background_im = Image.new("P", im_frame.size, background)
622
+ background_im.putpalette(im_frames[0]["im"].palette)
623
+ bbox = _getbbox(background_im, im_frame)
624
+ else:
625
+ bbox = None
626
+ im_frames.append({"im": im_frame, "bbox": bbox, "encoderinfo": encoderinfo})
627
+
628
+ if len(im_frames) > 1:
629
+ for frame_data in im_frames:
630
+ im_frame = frame_data["im"]
631
+ if not frame_data["bbox"]:
632
+ # global header
633
+ for s in _get_global_header(im_frame, frame_data["encoderinfo"]):
634
+ fp.write(s)
635
+ offset = (0, 0)
636
+ else:
637
+ # compress difference
638
+ if not palette:
639
+ frame_data["encoderinfo"]["include_color_table"] = True
640
+
641
+ im_frame = im_frame.crop(frame_data["bbox"])
642
+ offset = frame_data["bbox"][:2]
643
+ _write_frame_data(fp, im_frame, offset, frame_data["encoderinfo"])
644
+ return True
645
+ elif "duration" in im.encoderinfo and isinstance(
646
+ im.encoderinfo["duration"], (list, tuple)
647
+ ):
648
+ # Since multiple frames will not be written, add together the frame durations
649
+ im.encoderinfo["duration"] = sum(im.encoderinfo["duration"])
650
+
651
+
652
+ def _save_all(im, fp, filename):
653
+ _save(im, fp, filename, save_all=True)
654
+
655
+
656
+ def _save(im, fp, filename, save_all=False):
657
+ # header
658
+ if "palette" in im.encoderinfo or "palette" in im.info:
659
+ palette = im.encoderinfo.get("palette", im.info.get("palette"))
660
+ else:
661
+ palette = None
662
+ im.encoderinfo["optimize"] = im.encoderinfo.get("optimize", True)
663
+
664
+ if not save_all or not _write_multiple_frames(im, fp, palette):
665
+ _write_single_frame(im, fp, palette)
666
+
667
+ fp.write(b";") # end of file
668
+
669
+ if hasattr(fp, "flush"):
670
+ fp.flush()
671
+
672
+
673
+ def get_interlace(im):
674
+ interlace = im.encoderinfo.get("interlace", 1)
675
+
676
+ # workaround for @PIL153
677
+ if min(im.size) < 16:
678
+ interlace = 0
679
+
680
+ return interlace
681
+
682
+
683
+ def _write_local_header(fp, im, offset, flags):
684
+ transparent_color_exists = False
685
+ try:
686
+ transparency = int(im.encoderinfo["transparency"])
687
+ except (KeyError, ValueError):
688
+ pass
689
+ else:
690
+ # optimize the block away if transparent color is not used
691
+ transparent_color_exists = True
692
+
693
+ used_palette_colors = _get_optimize(im, im.encoderinfo)
694
+ if used_palette_colors is not None:
695
+ # adjust the transparency index after optimize
696
+ try:
697
+ transparency = used_palette_colors.index(transparency)
698
+ except ValueError:
699
+ transparent_color_exists = False
700
+
701
+ if "duration" in im.encoderinfo:
702
+ duration = int(im.encoderinfo["duration"] / 10)
703
+ else:
704
+ duration = 0
705
+
706
+ disposal = int(im.encoderinfo.get("disposal", 0))
707
+
708
+ if transparent_color_exists or duration != 0 or disposal:
709
+ packed_flag = 1 if transparent_color_exists else 0
710
+ packed_flag |= disposal << 2
711
+ if not transparent_color_exists:
712
+ transparency = 0
713
+
714
+ fp.write(
715
+ b"!"
716
+ + o8(249) # extension intro
717
+ + o8(4) # length
718
+ + o8(packed_flag) # packed fields
719
+ + o16(duration) # duration
720
+ + o8(transparency) # transparency index
721
+ + o8(0)
722
+ )
723
+
724
+ include_color_table = im.encoderinfo.get("include_color_table")
725
+ if include_color_table:
726
+ palette_bytes = _get_palette_bytes(im)
727
+ color_table_size = _get_color_table_size(palette_bytes)
728
+ if color_table_size:
729
+ flags = flags | 128 # local color table flag
730
+ flags = flags | color_table_size
731
+
732
+ fp.write(
733
+ b","
734
+ + o16(offset[0]) # offset
735
+ + o16(offset[1])
736
+ + o16(im.size[0]) # size
737
+ + o16(im.size[1])
738
+ + o8(flags) # flags
739
+ )
740
+ if include_color_table and color_table_size:
741
+ fp.write(_get_header_palette(palette_bytes))
742
+ fp.write(o8(8)) # bits
743
+
744
+
745
+ def _save_netpbm(im, fp, filename):
746
+ # Unused by default.
747
+ # To use, uncomment the register_save call at the end of the file.
748
+ #
749
+ # If you need real GIF compression and/or RGB quantization, you
750
+ # can use the external NETPBM/PBMPLUS utilities. See comments
751
+ # below for information on how to enable this.
752
+ tempfile = im._dump()
753
+
754
+ try:
755
+ with open(filename, "wb") as f:
756
+ if im.mode != "RGB":
757
+ subprocess.check_call(
758
+ ["ppmtogif", tempfile], stdout=f, stderr=subprocess.DEVNULL
759
+ )
760
+ else:
761
+ # Pipe ppmquant output into ppmtogif
762
+ # "ppmquant 256 %s | ppmtogif > %s" % (tempfile, filename)
763
+ quant_cmd = ["ppmquant", "256", tempfile]
764
+ togif_cmd = ["ppmtogif"]
765
+ quant_proc = subprocess.Popen(
766
+ quant_cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL
767
+ )
768
+ togif_proc = subprocess.Popen(
769
+ togif_cmd,
770
+ stdin=quant_proc.stdout,
771
+ stdout=f,
772
+ stderr=subprocess.DEVNULL,
773
+ )
774
+
775
+ # Allow ppmquant to receive SIGPIPE if ppmtogif exits
776
+ quant_proc.stdout.close()
777
+
778
+ retcode = quant_proc.wait()
779
+ if retcode:
780
+ raise subprocess.CalledProcessError(retcode, quant_cmd)
781
+
782
+ retcode = togif_proc.wait()
783
+ if retcode:
784
+ raise subprocess.CalledProcessError(retcode, togif_cmd)
785
+ finally:
786
+ try:
787
+ os.unlink(tempfile)
788
+ except OSError:
789
+ pass
790
+
791
+
792
+ # Force optimization so that we can test performance against
793
+ # cases where it took lots of memory and time previously.
794
+ _FORCE_OPTIMIZE = False
795
+
796
+
797
+ def _get_optimize(im, info):
798
+ """
799
+ Palette optimization is a potentially expensive operation.
800
+
801
+ This function determines if the palette should be optimized using
802
+ some heuristics, then returns the list of palette entries in use.
803
+
804
+ :param im: Image object
805
+ :param info: encoderinfo
806
+ :returns: list of indexes of palette entries in use, or None
807
+ """
808
+ if im.mode in ("P", "L") and info and info.get("optimize", 0):
809
+ # Potentially expensive operation.
810
+
811
+ # The palette saves 3 bytes per color not used, but palette
812
+ # lengths are restricted to 3*(2**N) bytes. Max saving would
813
+ # be 768 -> 6 bytes if we went all the way down to 2 colors.
814
+ # * If we're over 128 colors, we can't save any space.
815
+ # * If there aren't any holes, it's not worth collapsing.
816
+ # * If we have a 'large' image, the palette is in the noise.
817
+
818
+ # create the new palette if not every color is used
819
+ optimise = _FORCE_OPTIMIZE or im.mode == "L"
820
+ if optimise or im.width * im.height < 512 * 512:
821
+ # check which colors are used
822
+ used_palette_colors = []
823
+ for i, count in enumerate(im.histogram()):
824
+ if count:
825
+ used_palette_colors.append(i)
826
+
827
+ if optimise or max(used_palette_colors) >= len(used_palette_colors):
828
+ return used_palette_colors
829
+
830
+ num_palette_colors = len(im.palette.palette) // Image.getmodebands(
831
+ im.palette.mode
832
+ )
833
+ current_palette_size = 1 << (num_palette_colors - 1).bit_length()
834
+ if (
835
+ # check that the palette would become smaller when saved
836
+ len(used_palette_colors) <= current_palette_size // 2
837
+ # check that the palette is not already the smallest possible size
838
+ and current_palette_size > 2
839
+ ):
840
+ return used_palette_colors
841
+
842
+
843
+ def _get_color_table_size(palette_bytes):
844
+ # calculate the palette size for the header
845
+ if not palette_bytes:
846
+ return 0
847
+ elif len(palette_bytes) < 9:
848
+ return 1
849
+ else:
850
+ return math.ceil(math.log(len(palette_bytes) // 3, 2)) - 1
851
+
852
+
853
+ def _get_header_palette(palette_bytes):
854
+ """
855
+ Returns the palette, null padded to the next power of 2 (*3) bytes
856
+ suitable for direct inclusion in the GIF header
857
+
858
+ :param palette_bytes: Unpadded palette bytes, in RGBRGB form
859
+ :returns: Null padded palette
860
+ """
861
+ color_table_size = _get_color_table_size(palette_bytes)
862
+
863
+ # add the missing amount of bytes
864
+ # the palette has to be 2<<n in size
865
+ actual_target_size_diff = (2 << color_table_size) - len(palette_bytes) // 3
866
+ if actual_target_size_diff > 0:
867
+ palette_bytes += o8(0) * 3 * actual_target_size_diff
868
+ return palette_bytes
869
+
870
+
871
+ def _get_palette_bytes(im):
872
+ """
873
+ Gets the palette for inclusion in the gif header
874
+
875
+ :param im: Image object
876
+ :returns: Bytes, len<=768 suitable for inclusion in gif header
877
+ """
878
+ return im.palette.palette if im.palette else b""
879
+
880
+
881
+ def _get_background(im, info_background):
882
+ background = 0
883
+ if info_background:
884
+ if isinstance(info_background, tuple):
885
+ # WebPImagePlugin stores an RGBA value in info["background"]
886
+ # So it must be converted to the same format as GifImagePlugin's
887
+ # info["background"] - a global color table index
888
+ try:
889
+ background = im.palette.getcolor(info_background, im)
890
+ except ValueError as e:
891
+ if str(e) not in (
892
+ # If all 256 colors are in use,
893
+ # then there is no need for the background color
894
+ "cannot allocate more than 256 colors",
895
+ # Ignore non-opaque WebP background
896
+ "cannot add non-opaque RGBA color to RGB palette",
897
+ ):
898
+ raise
899
+ else:
900
+ background = info_background
901
+ return background
902
+
903
+
904
+ def _get_global_header(im, info):
905
+ """Return a list of strings representing a GIF header"""
906
+
907
+ # Header Block
908
+ # https://www.matthewflickinger.com/lab/whatsinagif/bits_and_bytes.asp
909
+
910
+ version = b"87a"
911
+ if im.info.get("version") == b"89a" or (
912
+ info
913
+ and (
914
+ "transparency" in info
915
+ or info.get("loop") is not None
916
+ or info.get("duration")
917
+ or info.get("comment")
918
+ )
919
+ ):
920
+ version = b"89a"
921
+
922
+ background = _get_background(im, info.get("background"))
923
+
924
+ palette_bytes = _get_palette_bytes(im)
925
+ color_table_size = _get_color_table_size(palette_bytes)
926
+
927
+ header = [
928
+ b"GIF" # signature
929
+ + version # version
930
+ + o16(im.size[0]) # canvas width
931
+ + o16(im.size[1]), # canvas height
932
+ # Logical Screen Descriptor
933
+ # size of global color table + global color table flag
934
+ o8(color_table_size + 128), # packed fields
935
+ # background + reserved/aspect
936
+ o8(background) + o8(0),
937
+ # Global Color Table
938
+ _get_header_palette(palette_bytes),
939
+ ]
940
+ if info.get("loop") is not None:
941
+ header.append(
942
+ b"!"
943
+ + o8(255) # extension intro
944
+ + o8(11)
945
+ + b"NETSCAPE2.0"
946
+ + o8(3)
947
+ + o8(1)
948
+ + o16(info["loop"]) # number of loops
949
+ + o8(0)
950
+ )
951
+ if info.get("comment"):
952
+ comment_block = b"!" + o8(254) # extension intro
953
+
954
+ comment = info["comment"]
955
+ if isinstance(comment, str):
956
+ comment = comment.encode()
957
+ for i in range(0, len(comment), 255):
958
+ subblock = comment[i : i + 255]
959
+ comment_block += o8(len(subblock)) + subblock
960
+
961
+ comment_block += o8(0)
962
+ header.append(comment_block)
963
+ return header
964
+
965
+
966
+ def _write_frame_data(fp, im_frame, offset, params):
967
+ try:
968
+ im_frame.encoderinfo = params
969
+
970
+ # local image header
971
+ _write_local_header(fp, im_frame, offset, 0)
972
+
973
+ ImageFile._save(
974
+ im_frame, fp, [("gif", (0, 0) + im_frame.size, 0, RAWMODE[im_frame.mode])]
975
+ )
976
+
977
+ fp.write(b"\0") # end of image data
978
+ finally:
979
+ del im_frame.encoderinfo
980
+
981
+
982
+ # --------------------------------------------------------------------
983
+ # Legacy GIF utilities
984
+
985
+
986
+ def getheader(im, palette=None, info=None):
987
+ """
988
+ Legacy Method to get Gif data from image.
989
+
990
+ Warning:: May modify image data.
991
+
992
+ :param im: Image object
993
+ :param palette: bytes object containing the source palette, or ....
994
+ :param info: encoderinfo
995
+ :returns: tuple of(list of header items, optimized palette)
996
+
997
+ """
998
+ used_palette_colors = _get_optimize(im, info)
999
+
1000
+ if info is None:
1001
+ info = {}
1002
+
1003
+ if "background" not in info and "background" in im.info:
1004
+ info["background"] = im.info["background"]
1005
+
1006
+ im_mod = _normalize_palette(im, palette, info)
1007
+ im.palette = im_mod.palette
1008
+ im.im = im_mod.im
1009
+ header = _get_global_header(im, info)
1010
+
1011
+ return header, used_palette_colors
1012
+
1013
+
1014
+ def getdata(im, offset=(0, 0), **params):
1015
+ """
1016
+ Legacy Method
1017
+
1018
+ Return a list of strings representing this image.
1019
+ The first string is a local image header, the rest contains
1020
+ encoded image data.
1021
+
1022
+ To specify duration, add the time in milliseconds,
1023
+ e.g. ``getdata(im_frame, duration=1000)``
1024
+
1025
+ :param im: Image object
1026
+ :param offset: Tuple of (x, y) pixels. Defaults to (0, 0)
1027
+ :param \\**params: e.g. duration or other encoder info parameters
1028
+ :returns: List of bytes containing GIF encoded frame data
1029
+
1030
+ """
1031
+
1032
+ class Collector:
1033
+ data = []
1034
+
1035
+ def write(self, data):
1036
+ self.data.append(data)
1037
+
1038
+ im.load() # make sure raster data is available
1039
+
1040
+ fp = Collector()
1041
+
1042
+ _write_frame_data(fp, im, offset, params)
1043
+
1044
+ return fp.data
1045
+
1046
+
1047
+ # --------------------------------------------------------------------
1048
+ # Registry
1049
+
1050
+ Image.register_open(GifImageFile.format, GifImageFile, _accept)
1051
+ Image.register_save(GifImageFile.format, _save)
1052
+ Image.register_save_all(GifImageFile.format, _save_all)
1053
+ Image.register_extension(GifImageFile.format, ".gif")
1054
+ Image.register_mime(GifImageFile.format, "image/gif")
1055
+
1056
+ #
1057
+ # Uncomment the following line if you wish to use NETPBM/PBMPLUS
1058
+ # instead of the built-in "uncompressed" GIF encoder
1059
+
1060
+ # Image.register_save(GifImageFile.format, _save_netpbm)
env/Lib/site-packages/PIL/GimpGradientFile.py ADDED
@@ -0,0 +1,137 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # Python Imaging Library
3
+ # $Id$
4
+ #
5
+ # stuff to read (and render) GIMP gradient files
6
+ #
7
+ # History:
8
+ # 97-08-23 fl Created
9
+ #
10
+ # Copyright (c) Secret Labs AB 1997.
11
+ # Copyright (c) Fredrik Lundh 1997.
12
+ #
13
+ # See the README file for information on usage and redistribution.
14
+ #
15
+
16
+ """
17
+ Stuff to translate curve segments to palette values (derived from
18
+ the corresponding code in GIMP, written by Federico Mena Quintero.
19
+ See the GIMP distribution for more information.)
20
+ """
21
+
22
+
23
+ from math import log, pi, sin, sqrt
24
+
25
+ from ._binary import o8
26
+
27
+ EPSILON = 1e-10
28
+ """""" # Enable auto-doc for data member
29
+
30
+
31
+ def linear(middle, pos):
32
+ if pos <= middle:
33
+ if middle < EPSILON:
34
+ return 0.0
35
+ else:
36
+ return 0.5 * pos / middle
37
+ else:
38
+ pos = pos - middle
39
+ middle = 1.0 - middle
40
+ if middle < EPSILON:
41
+ return 1.0
42
+ else:
43
+ return 0.5 + 0.5 * pos / middle
44
+
45
+
46
+ def curved(middle, pos):
47
+ return pos ** (log(0.5) / log(max(middle, EPSILON)))
48
+
49
+
50
+ def sine(middle, pos):
51
+ return (sin((-pi / 2.0) + pi * linear(middle, pos)) + 1.0) / 2.0
52
+
53
+
54
+ def sphere_increasing(middle, pos):
55
+ return sqrt(1.0 - (linear(middle, pos) - 1.0) ** 2)
56
+
57
+
58
+ def sphere_decreasing(middle, pos):
59
+ return 1.0 - sqrt(1.0 - linear(middle, pos) ** 2)
60
+
61
+
62
+ SEGMENTS = [linear, curved, sine, sphere_increasing, sphere_decreasing]
63
+ """""" # Enable auto-doc for data member
64
+
65
+
66
+ class GradientFile:
67
+ gradient = None
68
+
69
+ def getpalette(self, entries=256):
70
+ palette = []
71
+
72
+ ix = 0
73
+ x0, x1, xm, rgb0, rgb1, segment = self.gradient[ix]
74
+
75
+ for i in range(entries):
76
+ x = i / (entries - 1)
77
+
78
+ while x1 < x:
79
+ ix += 1
80
+ x0, x1, xm, rgb0, rgb1, segment = self.gradient[ix]
81
+
82
+ w = x1 - x0
83
+
84
+ if w < EPSILON:
85
+ scale = segment(0.5, 0.5)
86
+ else:
87
+ scale = segment((xm - x0) / w, (x - x0) / w)
88
+
89
+ # expand to RGBA
90
+ r = o8(int(255 * ((rgb1[0] - rgb0[0]) * scale + rgb0[0]) + 0.5))
91
+ g = o8(int(255 * ((rgb1[1] - rgb0[1]) * scale + rgb0[1]) + 0.5))
92
+ b = o8(int(255 * ((rgb1[2] - rgb0[2]) * scale + rgb0[2]) + 0.5))
93
+ a = o8(int(255 * ((rgb1[3] - rgb0[3]) * scale + rgb0[3]) + 0.5))
94
+
95
+ # add to palette
96
+ palette.append(r + g + b + a)
97
+
98
+ return b"".join(palette), "RGBA"
99
+
100
+
101
+ class GimpGradientFile(GradientFile):
102
+ """File handler for GIMP's gradient format."""
103
+
104
+ def __init__(self, fp):
105
+ if fp.readline()[:13] != b"GIMP Gradient":
106
+ msg = "not a GIMP gradient file"
107
+ raise SyntaxError(msg)
108
+
109
+ line = fp.readline()
110
+
111
+ # GIMP 1.2 gradient files don't contain a name, but GIMP 1.3 files do
112
+ if line.startswith(b"Name: "):
113
+ line = fp.readline().strip()
114
+
115
+ count = int(line)
116
+
117
+ gradient = []
118
+
119
+ for i in range(count):
120
+ s = fp.readline().split()
121
+ w = [float(x) for x in s[:11]]
122
+
123
+ x0, x1 = w[0], w[2]
124
+ xm = w[1]
125
+ rgb0 = w[3:7]
126
+ rgb1 = w[7:11]
127
+
128
+ segment = SEGMENTS[int(s[11])]
129
+ cspace = int(s[12])
130
+
131
+ if cspace != 0:
132
+ msg = "cannot handle HSV colour space"
133
+ raise OSError(msg)
134
+
135
+ gradient.append((x0, x1, xm, rgb0, rgb1, segment))
136
+
137
+ self.gradient = gradient
env/Lib/site-packages/PIL/GimpPaletteFile.py ADDED
@@ -0,0 +1,56 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # Python Imaging Library
3
+ # $Id$
4
+ #
5
+ # stuff to read GIMP palette files
6
+ #
7
+ # History:
8
+ # 1997-08-23 fl Created
9
+ # 2004-09-07 fl Support GIMP 2.0 palette files.
10
+ #
11
+ # Copyright (c) Secret Labs AB 1997-2004. All rights reserved.
12
+ # Copyright (c) Fredrik Lundh 1997-2004.
13
+ #
14
+ # See the README file for information on usage and redistribution.
15
+ #
16
+
17
+ import re
18
+
19
+ from ._binary import o8
20
+
21
+
22
+ class GimpPaletteFile:
23
+ """File handler for GIMP's palette format."""
24
+
25
+ rawmode = "RGB"
26
+
27
+ def __init__(self, fp):
28
+ self.palette = [o8(i) * 3 for i in range(256)]
29
+
30
+ if fp.readline()[:12] != b"GIMP Palette":
31
+ msg = "not a GIMP palette file"
32
+ raise SyntaxError(msg)
33
+
34
+ for i in range(256):
35
+ s = fp.readline()
36
+ if not s:
37
+ break
38
+
39
+ # skip fields and comment lines
40
+ if re.match(rb"\w+:|#", s):
41
+ continue
42
+ if len(s) > 100:
43
+ msg = "bad palette file"
44
+ raise SyntaxError(msg)
45
+
46
+ v = tuple(map(int, s.split()[:3]))
47
+ if len(v) != 3:
48
+ msg = "bad palette entry"
49
+ raise ValueError(msg)
50
+
51
+ self.palette[i] = o8(v[0]) + o8(v[1]) + o8(v[2])
52
+
53
+ self.palette = b"".join(self.palette)
54
+
55
+ def getpalette(self):
56
+ return self.palette, self.rawmode
env/Lib/site-packages/PIL/GribStubImagePlugin.py ADDED
@@ -0,0 +1,73 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library
3
+ # $Id$
4
+ #
5
+ # GRIB stub adapter
6
+ #
7
+ # Copyright (c) 1996-2003 by Fredrik Lundh
8
+ #
9
+ # See the README file for information on usage and redistribution.
10
+ #
11
+
12
+ from . import Image, ImageFile
13
+
14
+ _handler = None
15
+
16
+
17
+ def register_handler(handler):
18
+ """
19
+ Install application-specific GRIB image handler.
20
+
21
+ :param handler: Handler object.
22
+ """
23
+ global _handler
24
+ _handler = handler
25
+
26
+
27
+ # --------------------------------------------------------------------
28
+ # Image adapter
29
+
30
+
31
+ def _accept(prefix):
32
+ return prefix[:4] == b"GRIB" and prefix[7] == 1
33
+
34
+
35
+ class GribStubImageFile(ImageFile.StubImageFile):
36
+ format = "GRIB"
37
+ format_description = "GRIB"
38
+
39
+ def _open(self):
40
+ offset = self.fp.tell()
41
+
42
+ if not _accept(self.fp.read(8)):
43
+ msg = "Not a GRIB file"
44
+ raise SyntaxError(msg)
45
+
46
+ self.fp.seek(offset)
47
+
48
+ # make something up
49
+ self._mode = "F"
50
+ self._size = 1, 1
51
+
52
+ loader = self._load()
53
+ if loader:
54
+ loader.open(self)
55
+
56
+ def _load(self):
57
+ return _handler
58
+
59
+
60
+ def _save(im, fp, filename):
61
+ if _handler is None or not hasattr(_handler, "save"):
62
+ msg = "GRIB save handler not installed"
63
+ raise OSError(msg)
64
+ _handler.save(im, fp, filename)
65
+
66
+
67
+ # --------------------------------------------------------------------
68
+ # Registry
69
+
70
+ Image.register_open(GribStubImageFile.format, GribStubImageFile, _accept)
71
+ Image.register_save(GribStubImageFile.format, _save)
72
+
73
+ Image.register_extension(GribStubImageFile.format, ".grib")
env/Lib/site-packages/PIL/Hdf5StubImagePlugin.py ADDED
@@ -0,0 +1,73 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library
3
+ # $Id$
4
+ #
5
+ # HDF5 stub adapter
6
+ #
7
+ # Copyright (c) 2000-2003 by Fredrik Lundh
8
+ #
9
+ # See the README file for information on usage and redistribution.
10
+ #
11
+
12
+ from . import Image, ImageFile
13
+
14
+ _handler = None
15
+
16
+
17
+ def register_handler(handler):
18
+ """
19
+ Install application-specific HDF5 image handler.
20
+
21
+ :param handler: Handler object.
22
+ """
23
+ global _handler
24
+ _handler = handler
25
+
26
+
27
+ # --------------------------------------------------------------------
28
+ # Image adapter
29
+
30
+
31
+ def _accept(prefix):
32
+ return prefix[:8] == b"\x89HDF\r\n\x1a\n"
33
+
34
+
35
+ class HDF5StubImageFile(ImageFile.StubImageFile):
36
+ format = "HDF5"
37
+ format_description = "HDF5"
38
+
39
+ def _open(self):
40
+ offset = self.fp.tell()
41
+
42
+ if not _accept(self.fp.read(8)):
43
+ msg = "Not an HDF file"
44
+ raise SyntaxError(msg)
45
+
46
+ self.fp.seek(offset)
47
+
48
+ # make something up
49
+ self._mode = "F"
50
+ self._size = 1, 1
51
+
52
+ loader = self._load()
53
+ if loader:
54
+ loader.open(self)
55
+
56
+ def _load(self):
57
+ return _handler
58
+
59
+
60
+ def _save(im, fp, filename):
61
+ if _handler is None or not hasattr(_handler, "save"):
62
+ msg = "HDF5 save handler not installed"
63
+ raise OSError(msg)
64
+ _handler.save(im, fp, filename)
65
+
66
+
67
+ # --------------------------------------------------------------------
68
+ # Registry
69
+
70
+ Image.register_open(HDF5StubImageFile.format, HDF5StubImageFile, _accept)
71
+ Image.register_save(HDF5StubImageFile.format, _save)
72
+
73
+ Image.register_extensions(HDF5StubImageFile.format, [".h5", ".hdf"])
env/Lib/site-packages/PIL/IcnsImagePlugin.py ADDED
@@ -0,0 +1,399 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library.
3
+ # $Id$
4
+ #
5
+ # macOS icns file decoder, based on icns.py by Bob Ippolito.
6
+ #
7
+ # history:
8
+ # 2004-10-09 fl Turned into a PIL plugin; removed 2.3 dependencies.
9
+ # 2020-04-04 Allow saving on all operating systems.
10
+ #
11
+ # Copyright (c) 2004 by Bob Ippolito.
12
+ # Copyright (c) 2004 by Secret Labs.
13
+ # Copyright (c) 2004 by Fredrik Lundh.
14
+ # Copyright (c) 2014 by Alastair Houghton.
15
+ # Copyright (c) 2020 by Pan Jing.
16
+ #
17
+ # See the README file for information on usage and redistribution.
18
+ #
19
+
20
+ import io
21
+ import os
22
+ import struct
23
+ import sys
24
+
25
+ from . import Image, ImageFile, PngImagePlugin, features
26
+
27
+ enable_jpeg2k = features.check_codec("jpg_2000")
28
+ if enable_jpeg2k:
29
+ from . import Jpeg2KImagePlugin
30
+
31
+ MAGIC = b"icns"
32
+ HEADERSIZE = 8
33
+
34
+
35
+ def nextheader(fobj):
36
+ return struct.unpack(">4sI", fobj.read(HEADERSIZE))
37
+
38
+
39
+ def read_32t(fobj, start_length, size):
40
+ # The 128x128 icon seems to have an extra header for some reason.
41
+ (start, length) = start_length
42
+ fobj.seek(start)
43
+ sig = fobj.read(4)
44
+ if sig != b"\x00\x00\x00\x00":
45
+ msg = "Unknown signature, expecting 0x00000000"
46
+ raise SyntaxError(msg)
47
+ return read_32(fobj, (start + 4, length - 4), size)
48
+
49
+
50
+ def read_32(fobj, start_length, size):
51
+ """
52
+ Read a 32bit RGB icon resource. Seems to be either uncompressed or
53
+ an RLE packbits-like scheme.
54
+ """
55
+ (start, length) = start_length
56
+ fobj.seek(start)
57
+ pixel_size = (size[0] * size[2], size[1] * size[2])
58
+ sizesq = pixel_size[0] * pixel_size[1]
59
+ if length == sizesq * 3:
60
+ # uncompressed ("RGBRGBGB")
61
+ indata = fobj.read(length)
62
+ im = Image.frombuffer("RGB", pixel_size, indata, "raw", "RGB", 0, 1)
63
+ else:
64
+ # decode image
65
+ im = Image.new("RGB", pixel_size, None)
66
+ for band_ix in range(3):
67
+ data = []
68
+ bytesleft = sizesq
69
+ while bytesleft > 0:
70
+ byte = fobj.read(1)
71
+ if not byte:
72
+ break
73
+ byte = byte[0]
74
+ if byte & 0x80:
75
+ blocksize = byte - 125
76
+ byte = fobj.read(1)
77
+ for i in range(blocksize):
78
+ data.append(byte)
79
+ else:
80
+ blocksize = byte + 1
81
+ data.append(fobj.read(blocksize))
82
+ bytesleft -= blocksize
83
+ if bytesleft <= 0:
84
+ break
85
+ if bytesleft != 0:
86
+ msg = f"Error reading channel [{repr(bytesleft)} left]"
87
+ raise SyntaxError(msg)
88
+ band = Image.frombuffer("L", pixel_size, b"".join(data), "raw", "L", 0, 1)
89
+ im.im.putband(band.im, band_ix)
90
+ return {"RGB": im}
91
+
92
+
93
+ def read_mk(fobj, start_length, size):
94
+ # Alpha masks seem to be uncompressed
95
+ start = start_length[0]
96
+ fobj.seek(start)
97
+ pixel_size = (size[0] * size[2], size[1] * size[2])
98
+ sizesq = pixel_size[0] * pixel_size[1]
99
+ band = Image.frombuffer("L", pixel_size, fobj.read(sizesq), "raw", "L", 0, 1)
100
+ return {"A": band}
101
+
102
+
103
+ def read_png_or_jpeg2000(fobj, start_length, size):
104
+ (start, length) = start_length
105
+ fobj.seek(start)
106
+ sig = fobj.read(12)
107
+ if sig[:8] == b"\x89PNG\x0d\x0a\x1a\x0a":
108
+ fobj.seek(start)
109
+ im = PngImagePlugin.PngImageFile(fobj)
110
+ Image._decompression_bomb_check(im.size)
111
+ return {"RGBA": im}
112
+ elif (
113
+ sig[:4] == b"\xff\x4f\xff\x51"
114
+ or sig[:4] == b"\x0d\x0a\x87\x0a"
115
+ or sig == b"\x00\x00\x00\x0cjP \x0d\x0a\x87\x0a"
116
+ ):
117
+ if not enable_jpeg2k:
118
+ msg = (
119
+ "Unsupported icon subimage format (rebuild PIL "
120
+ "with JPEG 2000 support to fix this)"
121
+ )
122
+ raise ValueError(msg)
123
+ # j2k, jpc or j2c
124
+ fobj.seek(start)
125
+ jp2kstream = fobj.read(length)
126
+ f = io.BytesIO(jp2kstream)
127
+ im = Jpeg2KImagePlugin.Jpeg2KImageFile(f)
128
+ Image._decompression_bomb_check(im.size)
129
+ if im.mode != "RGBA":
130
+ im = im.convert("RGBA")
131
+ return {"RGBA": im}
132
+ else:
133
+ msg = "Unsupported icon subimage format"
134
+ raise ValueError(msg)
135
+
136
+
137
+ class IcnsFile:
138
+ SIZES = {
139
+ (512, 512, 2): [(b"ic10", read_png_or_jpeg2000)],
140
+ (512, 512, 1): [(b"ic09", read_png_or_jpeg2000)],
141
+ (256, 256, 2): [(b"ic14", read_png_or_jpeg2000)],
142
+ (256, 256, 1): [(b"ic08", read_png_or_jpeg2000)],
143
+ (128, 128, 2): [(b"ic13", read_png_or_jpeg2000)],
144
+ (128, 128, 1): [
145
+ (b"ic07", read_png_or_jpeg2000),
146
+ (b"it32", read_32t),
147
+ (b"t8mk", read_mk),
148
+ ],
149
+ (64, 64, 1): [(b"icp6", read_png_or_jpeg2000)],
150
+ (32, 32, 2): [(b"ic12", read_png_or_jpeg2000)],
151
+ (48, 48, 1): [(b"ih32", read_32), (b"h8mk", read_mk)],
152
+ (32, 32, 1): [
153
+ (b"icp5", read_png_or_jpeg2000),
154
+ (b"il32", read_32),
155
+ (b"l8mk", read_mk),
156
+ ],
157
+ (16, 16, 2): [(b"ic11", read_png_or_jpeg2000)],
158
+ (16, 16, 1): [
159
+ (b"icp4", read_png_or_jpeg2000),
160
+ (b"is32", read_32),
161
+ (b"s8mk", read_mk),
162
+ ],
163
+ }
164
+
165
+ def __init__(self, fobj):
166
+ """
167
+ fobj is a file-like object as an icns resource
168
+ """
169
+ # signature : (start, length)
170
+ self.dct = dct = {}
171
+ self.fobj = fobj
172
+ sig, filesize = nextheader(fobj)
173
+ if not _accept(sig):
174
+ msg = "not an icns file"
175
+ raise SyntaxError(msg)
176
+ i = HEADERSIZE
177
+ while i < filesize:
178
+ sig, blocksize = nextheader(fobj)
179
+ if blocksize <= 0:
180
+ msg = "invalid block header"
181
+ raise SyntaxError(msg)
182
+ i += HEADERSIZE
183
+ blocksize -= HEADERSIZE
184
+ dct[sig] = (i, blocksize)
185
+ fobj.seek(blocksize, io.SEEK_CUR)
186
+ i += blocksize
187
+
188
+ def itersizes(self):
189
+ sizes = []
190
+ for size, fmts in self.SIZES.items():
191
+ for fmt, reader in fmts:
192
+ if fmt in self.dct:
193
+ sizes.append(size)
194
+ break
195
+ return sizes
196
+
197
+ def bestsize(self):
198
+ sizes = self.itersizes()
199
+ if not sizes:
200
+ msg = "No 32bit icon resources found"
201
+ raise SyntaxError(msg)
202
+ return max(sizes)
203
+
204
+ def dataforsize(self, size):
205
+ """
206
+ Get an icon resource as {channel: array}. Note that
207
+ the arrays are bottom-up like windows bitmaps and will likely
208
+ need to be flipped or transposed in some way.
209
+ """
210
+ dct = {}
211
+ for code, reader in self.SIZES[size]:
212
+ desc = self.dct.get(code)
213
+ if desc is not None:
214
+ dct.update(reader(self.fobj, desc, size))
215
+ return dct
216
+
217
+ def getimage(self, size=None):
218
+ if size is None:
219
+ size = self.bestsize()
220
+ if len(size) == 2:
221
+ size = (size[0], size[1], 1)
222
+ channels = self.dataforsize(size)
223
+
224
+ im = channels.get("RGBA", None)
225
+ if im:
226
+ return im
227
+
228
+ im = channels.get("RGB").copy()
229
+ try:
230
+ im.putalpha(channels["A"])
231
+ except KeyError:
232
+ pass
233
+ return im
234
+
235
+
236
+ ##
237
+ # Image plugin for Mac OS icons.
238
+
239
+
240
+ class IcnsImageFile(ImageFile.ImageFile):
241
+ """
242
+ PIL image support for Mac OS .icns files.
243
+ Chooses the best resolution, but will possibly load
244
+ a different size image if you mutate the size attribute
245
+ before calling 'load'.
246
+
247
+ The info dictionary has a key 'sizes' that is a list
248
+ of sizes that the icns file has.
249
+ """
250
+
251
+ format = "ICNS"
252
+ format_description = "Mac OS icns resource"
253
+
254
+ def _open(self):
255
+ self.icns = IcnsFile(self.fp)
256
+ self._mode = "RGBA"
257
+ self.info["sizes"] = self.icns.itersizes()
258
+ self.best_size = self.icns.bestsize()
259
+ self.size = (
260
+ self.best_size[0] * self.best_size[2],
261
+ self.best_size[1] * self.best_size[2],
262
+ )
263
+
264
+ @property
265
+ def size(self):
266
+ return self._size
267
+
268
+ @size.setter
269
+ def size(self, value):
270
+ info_size = value
271
+ if info_size not in self.info["sizes"] and len(info_size) == 2:
272
+ info_size = (info_size[0], info_size[1], 1)
273
+ if (
274
+ info_size not in self.info["sizes"]
275
+ and len(info_size) == 3
276
+ and info_size[2] == 1
277
+ ):
278
+ simple_sizes = [
279
+ (size[0] * size[2], size[1] * size[2]) for size in self.info["sizes"]
280
+ ]
281
+ if value in simple_sizes:
282
+ info_size = self.info["sizes"][simple_sizes.index(value)]
283
+ if info_size not in self.info["sizes"]:
284
+ msg = "This is not one of the allowed sizes of this image"
285
+ raise ValueError(msg)
286
+ self._size = value
287
+
288
+ def load(self):
289
+ if len(self.size) == 3:
290
+ self.best_size = self.size
291
+ self.size = (
292
+ self.best_size[0] * self.best_size[2],
293
+ self.best_size[1] * self.best_size[2],
294
+ )
295
+
296
+ px = Image.Image.load(self)
297
+ if self.im is not None and self.im.size == self.size:
298
+ # Already loaded
299
+ return px
300
+ self.load_prepare()
301
+ # This is likely NOT the best way to do it, but whatever.
302
+ im = self.icns.getimage(self.best_size)
303
+
304
+ # If this is a PNG or JPEG 2000, it won't be loaded yet
305
+ px = im.load()
306
+
307
+ self.im = im.im
308
+ self._mode = im.mode
309
+ self.size = im.size
310
+
311
+ return px
312
+
313
+
314
+ def _save(im, fp, filename):
315
+ """
316
+ Saves the image as a series of PNG files,
317
+ that are then combined into a .icns file.
318
+ """
319
+ if hasattr(fp, "flush"):
320
+ fp.flush()
321
+
322
+ sizes = {
323
+ b"ic07": 128,
324
+ b"ic08": 256,
325
+ b"ic09": 512,
326
+ b"ic10": 1024,
327
+ b"ic11": 32,
328
+ b"ic12": 64,
329
+ b"ic13": 256,
330
+ b"ic14": 512,
331
+ }
332
+ provided_images = {im.width: im for im in im.encoderinfo.get("append_images", [])}
333
+ size_streams = {}
334
+ for size in set(sizes.values()):
335
+ image = (
336
+ provided_images[size]
337
+ if size in provided_images
338
+ else im.resize((size, size))
339
+ )
340
+
341
+ temp = io.BytesIO()
342
+ image.save(temp, "png")
343
+ size_streams[size] = temp.getvalue()
344
+
345
+ entries = []
346
+ for type, size in sizes.items():
347
+ stream = size_streams[size]
348
+ entries.append(
349
+ {"type": type, "size": HEADERSIZE + len(stream), "stream": stream}
350
+ )
351
+
352
+ # Header
353
+ fp.write(MAGIC)
354
+ file_length = HEADERSIZE # Header
355
+ file_length += HEADERSIZE + 8 * len(entries) # TOC
356
+ file_length += sum(entry["size"] for entry in entries)
357
+ fp.write(struct.pack(">i", file_length))
358
+
359
+ # TOC
360
+ fp.write(b"TOC ")
361
+ fp.write(struct.pack(">i", HEADERSIZE + len(entries) * HEADERSIZE))
362
+ for entry in entries:
363
+ fp.write(entry["type"])
364
+ fp.write(struct.pack(">i", entry["size"]))
365
+
366
+ # Data
367
+ for entry in entries:
368
+ fp.write(entry["type"])
369
+ fp.write(struct.pack(">i", entry["size"]))
370
+ fp.write(entry["stream"])
371
+
372
+ if hasattr(fp, "flush"):
373
+ fp.flush()
374
+
375
+
376
+ def _accept(prefix):
377
+ return prefix[:4] == MAGIC
378
+
379
+
380
+ Image.register_open(IcnsImageFile.format, IcnsImageFile, _accept)
381
+ Image.register_extension(IcnsImageFile.format, ".icns")
382
+
383
+ Image.register_save(IcnsImageFile.format, _save)
384
+ Image.register_mime(IcnsImageFile.format, "image/icns")
385
+
386
+ if __name__ == "__main__":
387
+ if len(sys.argv) < 2:
388
+ print("Syntax: python3 IcnsImagePlugin.py [file]")
389
+ sys.exit()
390
+
391
+ with open(sys.argv[1], "rb") as fp:
392
+ imf = IcnsImageFile(fp)
393
+ for size in imf.info["sizes"]:
394
+ imf.size = size
395
+ imf.save("out-%s-%s-%s.png" % size)
396
+ with Image.open(sys.argv[1]) as im:
397
+ im.save("out.png")
398
+ if sys.platform == "windows":
399
+ os.startfile("out.png")
env/Lib/site-packages/PIL/IcoImagePlugin.py ADDED
@@ -0,0 +1,358 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library.
3
+ # $Id$
4
+ #
5
+ # Windows Icon support for PIL
6
+ #
7
+ # History:
8
+ # 96-05-27 fl Created
9
+ #
10
+ # Copyright (c) Secret Labs AB 1997.
11
+ # Copyright (c) Fredrik Lundh 1996.
12
+ #
13
+ # See the README file for information on usage and redistribution.
14
+ #
15
+
16
+ # This plugin is a refactored version of Win32IconImagePlugin by Bryan Davis
17
18
+ # https://code.google.com/archive/p/casadebender/wikis/Win32IconImagePlugin.wiki
19
+ #
20
+ # Icon format references:
21
+ # * https://en.wikipedia.org/wiki/ICO_(file_format)
22
+ # * https://msdn.microsoft.com/en-us/library/ms997538.aspx
23
+
24
+
25
+ import warnings
26
+ from io import BytesIO
27
+ from math import ceil, log
28
+
29
+ from . import BmpImagePlugin, Image, ImageFile, PngImagePlugin
30
+ from ._binary import i16le as i16
31
+ from ._binary import i32le as i32
32
+ from ._binary import o8
33
+ from ._binary import o16le as o16
34
+ from ._binary import o32le as o32
35
+
36
+ #
37
+ # --------------------------------------------------------------------
38
+
39
+ _MAGIC = b"\0\0\1\0"
40
+
41
+
42
+ def _save(im, fp, filename):
43
+ fp.write(_MAGIC) # (2+2)
44
+ bmp = im.encoderinfo.get("bitmap_format") == "bmp"
45
+ sizes = im.encoderinfo.get(
46
+ "sizes",
47
+ [(16, 16), (24, 24), (32, 32), (48, 48), (64, 64), (128, 128), (256, 256)],
48
+ )
49
+ frames = []
50
+ provided_ims = [im] + im.encoderinfo.get("append_images", [])
51
+ width, height = im.size
52
+ for size in sorted(set(sizes)):
53
+ if size[0] > width or size[1] > height or size[0] > 256 or size[1] > 256:
54
+ continue
55
+
56
+ for provided_im in provided_ims:
57
+ if provided_im.size != size:
58
+ continue
59
+ frames.append(provided_im)
60
+ if bmp:
61
+ bits = BmpImagePlugin.SAVE[provided_im.mode][1]
62
+ bits_used = [bits]
63
+ for other_im in provided_ims:
64
+ if other_im.size != size:
65
+ continue
66
+ bits = BmpImagePlugin.SAVE[other_im.mode][1]
67
+ if bits not in bits_used:
68
+ # Another image has been supplied for this size
69
+ # with a different bit depth
70
+ frames.append(other_im)
71
+ bits_used.append(bits)
72
+ break
73
+ else:
74
+ # TODO: invent a more convenient method for proportional scalings
75
+ frame = provided_im.copy()
76
+ frame.thumbnail(size, Image.Resampling.LANCZOS, reducing_gap=None)
77
+ frames.append(frame)
78
+ fp.write(o16(len(frames))) # idCount(2)
79
+ offset = fp.tell() + len(frames) * 16
80
+ for frame in frames:
81
+ width, height = frame.size
82
+ # 0 means 256
83
+ fp.write(o8(width if width < 256 else 0)) # bWidth(1)
84
+ fp.write(o8(height if height < 256 else 0)) # bHeight(1)
85
+
86
+ bits, colors = BmpImagePlugin.SAVE[frame.mode][1:] if bmp else (32, 0)
87
+ fp.write(o8(colors)) # bColorCount(1)
88
+ fp.write(b"\0") # bReserved(1)
89
+ fp.write(b"\0\0") # wPlanes(2)
90
+ fp.write(o16(bits)) # wBitCount(2)
91
+
92
+ image_io = BytesIO()
93
+ if bmp:
94
+ frame.save(image_io, "dib")
95
+
96
+ if bits != 32:
97
+ and_mask = Image.new("1", size)
98
+ ImageFile._save(
99
+ and_mask, image_io, [("raw", (0, 0) + size, 0, ("1", 0, -1))]
100
+ )
101
+ else:
102
+ frame.save(image_io, "png")
103
+ image_io.seek(0)
104
+ image_bytes = image_io.read()
105
+ if bmp:
106
+ image_bytes = image_bytes[:8] + o32(height * 2) + image_bytes[12:]
107
+ bytes_len = len(image_bytes)
108
+ fp.write(o32(bytes_len)) # dwBytesInRes(4)
109
+ fp.write(o32(offset)) # dwImageOffset(4)
110
+ current = fp.tell()
111
+ fp.seek(offset)
112
+ fp.write(image_bytes)
113
+ offset = offset + bytes_len
114
+ fp.seek(current)
115
+
116
+
117
+ def _accept(prefix):
118
+ return prefix[:4] == _MAGIC
119
+
120
+
121
+ class IcoFile:
122
+ def __init__(self, buf):
123
+ """
124
+ Parse image from file-like object containing ico file data
125
+ """
126
+
127
+ # check magic
128
+ s = buf.read(6)
129
+ if not _accept(s):
130
+ msg = "not an ICO file"
131
+ raise SyntaxError(msg)
132
+
133
+ self.buf = buf
134
+ self.entry = []
135
+
136
+ # Number of items in file
137
+ self.nb_items = i16(s, 4)
138
+
139
+ # Get headers for each item
140
+ for i in range(self.nb_items):
141
+ s = buf.read(16)
142
+
143
+ icon_header = {
144
+ "width": s[0],
145
+ "height": s[1],
146
+ "nb_color": s[2], # No. of colors in image (0 if >=8bpp)
147
+ "reserved": s[3],
148
+ "planes": i16(s, 4),
149
+ "bpp": i16(s, 6),
150
+ "size": i32(s, 8),
151
+ "offset": i32(s, 12),
152
+ }
153
+
154
+ # See Wikipedia
155
+ for j in ("width", "height"):
156
+ if not icon_header[j]:
157
+ icon_header[j] = 256
158
+
159
+ # See Wikipedia notes about color depth.
160
+ # We need this just to differ images with equal sizes
161
+ icon_header["color_depth"] = (
162
+ icon_header["bpp"]
163
+ or (
164
+ icon_header["nb_color"] != 0
165
+ and ceil(log(icon_header["nb_color"], 2))
166
+ )
167
+ or 256
168
+ )
169
+
170
+ icon_header["dim"] = (icon_header["width"], icon_header["height"])
171
+ icon_header["square"] = icon_header["width"] * icon_header["height"]
172
+
173
+ self.entry.append(icon_header)
174
+
175
+ self.entry = sorted(self.entry, key=lambda x: x["color_depth"])
176
+ # ICO images are usually squares
177
+ # self.entry = sorted(self.entry, key=lambda x: x['width'])
178
+ self.entry = sorted(self.entry, key=lambda x: x["square"])
179
+ self.entry.reverse()
180
+
181
+ def sizes(self):
182
+ """
183
+ Get a list of all available icon sizes and color depths.
184
+ """
185
+ return {(h["width"], h["height"]) for h in self.entry}
186
+
187
+ def getentryindex(self, size, bpp=False):
188
+ for i, h in enumerate(self.entry):
189
+ if size == h["dim"] and (bpp is False or bpp == h["color_depth"]):
190
+ return i
191
+ return 0
192
+
193
+ def getimage(self, size, bpp=False):
194
+ """
195
+ Get an image from the icon
196
+ """
197
+ return self.frame(self.getentryindex(size, bpp))
198
+
199
+ def frame(self, idx):
200
+ """
201
+ Get an image from frame idx
202
+ """
203
+
204
+ header = self.entry[idx]
205
+
206
+ self.buf.seek(header["offset"])
207
+ data = self.buf.read(8)
208
+ self.buf.seek(header["offset"])
209
+
210
+ if data[:8] == PngImagePlugin._MAGIC:
211
+ # png frame
212
+ im = PngImagePlugin.PngImageFile(self.buf)
213
+ Image._decompression_bomb_check(im.size)
214
+ else:
215
+ # XOR + AND mask bmp frame
216
+ im = BmpImagePlugin.DibImageFile(self.buf)
217
+ Image._decompression_bomb_check(im.size)
218
+
219
+ # change tile dimension to only encompass XOR image
220
+ im._size = (im.size[0], int(im.size[1] / 2))
221
+ d, e, o, a = im.tile[0]
222
+ im.tile[0] = d, (0, 0) + im.size, o, a
223
+
224
+ # figure out where AND mask image starts
225
+ bpp = header["bpp"]
226
+ if 32 == bpp:
227
+ # 32-bit color depth icon image allows semitransparent areas
228
+ # PIL's DIB format ignores transparency bits, recover them.
229
+ # The DIB is packed in BGRX byte order where X is the alpha
230
+ # channel.
231
+
232
+ # Back up to start of bmp data
233
+ self.buf.seek(o)
234
+ # extract every 4th byte (eg. 3,7,11,15,...)
235
+ alpha_bytes = self.buf.read(im.size[0] * im.size[1] * 4)[3::4]
236
+
237
+ # convert to an 8bpp grayscale image
238
+ mask = Image.frombuffer(
239
+ "L", # 8bpp
240
+ im.size, # (w, h)
241
+ alpha_bytes, # source chars
242
+ "raw", # raw decoder
243
+ ("L", 0, -1), # 8bpp inverted, unpadded, reversed
244
+ )
245
+ else:
246
+ # get AND image from end of bitmap
247
+ w = im.size[0]
248
+ if (w % 32) > 0:
249
+ # bitmap row data is aligned to word boundaries
250
+ w += 32 - (im.size[0] % 32)
251
+
252
+ # the total mask data is
253
+ # padded row size * height / bits per char
254
+
255
+ total_bytes = int((w * im.size[1]) / 8)
256
+ and_mask_offset = header["offset"] + header["size"] - total_bytes
257
+
258
+ self.buf.seek(and_mask_offset)
259
+ mask_data = self.buf.read(total_bytes)
260
+
261
+ # convert raw data to image
262
+ mask = Image.frombuffer(
263
+ "1", # 1 bpp
264
+ im.size, # (w, h)
265
+ mask_data, # source chars
266
+ "raw", # raw decoder
267
+ ("1;I", int(w / 8), -1), # 1bpp inverted, padded, reversed
268
+ )
269
+
270
+ # now we have two images, im is XOR image and mask is AND image
271
+
272
+ # apply mask image as alpha channel
273
+ im = im.convert("RGBA")
274
+ im.putalpha(mask)
275
+
276
+ return im
277
+
278
+
279
+ ##
280
+ # Image plugin for Windows Icon files.
281
+
282
+
283
+ class IcoImageFile(ImageFile.ImageFile):
284
+ """
285
+ PIL read-only image support for Microsoft Windows .ico files.
286
+
287
+ By default the largest resolution image in the file will be loaded. This
288
+ can be changed by altering the 'size' attribute before calling 'load'.
289
+
290
+ The info dictionary has a key 'sizes' that is a list of the sizes available
291
+ in the icon file.
292
+
293
+ Handles classic, XP and Vista icon formats.
294
+
295
+ When saving, PNG compression is used. Support for this was only added in
296
+ Windows Vista. If you are unable to view the icon in Windows, convert the
297
+ image to "RGBA" mode before saving.
298
+
299
+ This plugin is a refactored version of Win32IconImagePlugin by Bryan Davis
300
301
+ https://code.google.com/archive/p/casadebender/wikis/Win32IconImagePlugin.wiki
302
+ """
303
+
304
+ format = "ICO"
305
+ format_description = "Windows Icon"
306
+
307
+ def _open(self):
308
+ self.ico = IcoFile(self.fp)
309
+ self.info["sizes"] = self.ico.sizes()
310
+ self.size = self.ico.entry[0]["dim"]
311
+ self.load()
312
+
313
+ @property
314
+ def size(self):
315
+ return self._size
316
+
317
+ @size.setter
318
+ def size(self, value):
319
+ if value not in self.info["sizes"]:
320
+ msg = "This is not one of the allowed sizes of this image"
321
+ raise ValueError(msg)
322
+ self._size = value
323
+
324
+ def load(self):
325
+ if self.im is not None and self.im.size == self.size:
326
+ # Already loaded
327
+ return Image.Image.load(self)
328
+ im = self.ico.getimage(self.size)
329
+ # if tile is PNG, it won't really be loaded yet
330
+ im.load()
331
+ self.im = im.im
332
+ self.pyaccess = None
333
+ self._mode = im.mode
334
+ if im.size != self.size:
335
+ warnings.warn("Image was not the expected size")
336
+
337
+ index = self.ico.getentryindex(self.size)
338
+ sizes = list(self.info["sizes"])
339
+ sizes[index] = im.size
340
+ self.info["sizes"] = set(sizes)
341
+
342
+ self.size = im.size
343
+
344
+ def load_seek(self):
345
+ # Flag the ImageFile.Parser so that it
346
+ # just does all the decode at the end.
347
+ pass
348
+
349
+
350
+ #
351
+ # --------------------------------------------------------------------
352
+
353
+
354
+ Image.register_open(IcoImageFile.format, IcoImageFile, _accept)
355
+ Image.register_save(IcoImageFile.format, _save)
356
+ Image.register_extension(IcoImageFile.format, ".ico")
357
+
358
+ Image.register_mime(IcoImageFile.format, "image/x-icon")
env/Lib/site-packages/PIL/ImImagePlugin.py ADDED
@@ -0,0 +1,371 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library.
3
+ # $Id$
4
+ #
5
+ # IFUNC IM file handling for PIL
6
+ #
7
+ # history:
8
+ # 1995-09-01 fl Created.
9
+ # 1997-01-03 fl Save palette images
10
+ # 1997-01-08 fl Added sequence support
11
+ # 1997-01-23 fl Added P and RGB save support
12
+ # 1997-05-31 fl Read floating point images
13
+ # 1997-06-22 fl Save floating point images
14
+ # 1997-08-27 fl Read and save 1-bit images
15
+ # 1998-06-25 fl Added support for RGB+LUT images
16
+ # 1998-07-02 fl Added support for YCC images
17
+ # 1998-07-15 fl Renamed offset attribute to avoid name clash
18
+ # 1998-12-29 fl Added I;16 support
19
+ # 2001-02-17 fl Use 're' instead of 'regex' (Python 2.1) (0.7)
20
+ # 2003-09-26 fl Added LA/PA support
21
+ #
22
+ # Copyright (c) 1997-2003 by Secret Labs AB.
23
+ # Copyright (c) 1995-2001 by Fredrik Lundh.
24
+ #
25
+ # See the README file for information on usage and redistribution.
26
+ #
27
+
28
+
29
+ import os
30
+ import re
31
+
32
+ from . import Image, ImageFile, ImagePalette
33
+
34
+ # --------------------------------------------------------------------
35
+ # Standard tags
36
+
37
+ COMMENT = "Comment"
38
+ DATE = "Date"
39
+ EQUIPMENT = "Digitalization equipment"
40
+ FRAMES = "File size (no of images)"
41
+ LUT = "Lut"
42
+ NAME = "Name"
43
+ SCALE = "Scale (x,y)"
44
+ SIZE = "Image size (x*y)"
45
+ MODE = "Image type"
46
+
47
+ TAGS = {
48
+ COMMENT: 0,
49
+ DATE: 0,
50
+ EQUIPMENT: 0,
51
+ FRAMES: 0,
52
+ LUT: 0,
53
+ NAME: 0,
54
+ SCALE: 0,
55
+ SIZE: 0,
56
+ MODE: 0,
57
+ }
58
+
59
+ OPEN = {
60
+ # ifunc93/p3cfunc formats
61
+ "0 1 image": ("1", "1"),
62
+ "L 1 image": ("1", "1"),
63
+ "Greyscale image": ("L", "L"),
64
+ "Grayscale image": ("L", "L"),
65
+ "RGB image": ("RGB", "RGB;L"),
66
+ "RLB image": ("RGB", "RLB"),
67
+ "RYB image": ("RGB", "RLB"),
68
+ "B1 image": ("1", "1"),
69
+ "B2 image": ("P", "P;2"),
70
+ "B4 image": ("P", "P;4"),
71
+ "X 24 image": ("RGB", "RGB"),
72
+ "L 32 S image": ("I", "I;32"),
73
+ "L 32 F image": ("F", "F;32"),
74
+ # old p3cfunc formats
75
+ "RGB3 image": ("RGB", "RGB;T"),
76
+ "RYB3 image": ("RGB", "RYB;T"),
77
+ # extensions
78
+ "LA image": ("LA", "LA;L"),
79
+ "PA image": ("LA", "PA;L"),
80
+ "RGBA image": ("RGBA", "RGBA;L"),
81
+ "RGBX image": ("RGBX", "RGBX;L"),
82
+ "CMYK image": ("CMYK", "CMYK;L"),
83
+ "YCC image": ("YCbCr", "YCbCr;L"),
84
+ }
85
+
86
+ # ifunc95 extensions
87
+ for i in ["8", "8S", "16", "16S", "32", "32F"]:
88
+ OPEN[f"L {i} image"] = ("F", f"F;{i}")
89
+ OPEN[f"L*{i} image"] = ("F", f"F;{i}")
90
+ for i in ["16", "16L", "16B"]:
91
+ OPEN[f"L {i} image"] = (f"I;{i}", f"I;{i}")
92
+ OPEN[f"L*{i} image"] = (f"I;{i}", f"I;{i}")
93
+ for i in ["32S"]:
94
+ OPEN[f"L {i} image"] = ("I", f"I;{i}")
95
+ OPEN[f"L*{i} image"] = ("I", f"I;{i}")
96
+ for i in range(2, 33):
97
+ OPEN[f"L*{i} image"] = ("F", f"F;{i}")
98
+
99
+
100
+ # --------------------------------------------------------------------
101
+ # Read IM directory
102
+
103
+ split = re.compile(rb"^([A-Za-z][^:]*):[ \t]*(.*)[ \t]*$")
104
+
105
+
106
+ def number(s):
107
+ try:
108
+ return int(s)
109
+ except ValueError:
110
+ return float(s)
111
+
112
+
113
+ ##
114
+ # Image plugin for the IFUNC IM file format.
115
+
116
+
117
+ class ImImageFile(ImageFile.ImageFile):
118
+ format = "IM"
119
+ format_description = "IFUNC Image Memory"
120
+ _close_exclusive_fp_after_loading = False
121
+
122
+ def _open(self):
123
+ # Quick rejection: if there's not an LF among the first
124
+ # 100 bytes, this is (probably) not a text header.
125
+
126
+ if b"\n" not in self.fp.read(100):
127
+ msg = "not an IM file"
128
+ raise SyntaxError(msg)
129
+ self.fp.seek(0)
130
+
131
+ n = 0
132
+
133
+ # Default values
134
+ self.info[MODE] = "L"
135
+ self.info[SIZE] = (512, 512)
136
+ self.info[FRAMES] = 1
137
+
138
+ self.rawmode = "L"
139
+
140
+ while True:
141
+ s = self.fp.read(1)
142
+
143
+ # Some versions of IFUNC uses \n\r instead of \r\n...
144
+ if s == b"\r":
145
+ continue
146
+
147
+ if not s or s == b"\0" or s == b"\x1A":
148
+ break
149
+
150
+ # FIXME: this may read whole file if not a text file
151
+ s = s + self.fp.readline()
152
+
153
+ if len(s) > 100:
154
+ msg = "not an IM file"
155
+ raise SyntaxError(msg)
156
+
157
+ if s[-2:] == b"\r\n":
158
+ s = s[:-2]
159
+ elif s[-1:] == b"\n":
160
+ s = s[:-1]
161
+
162
+ try:
163
+ m = split.match(s)
164
+ except re.error as e:
165
+ msg = "not an IM file"
166
+ raise SyntaxError(msg) from e
167
+
168
+ if m:
169
+ k, v = m.group(1, 2)
170
+
171
+ # Don't know if this is the correct encoding,
172
+ # but a decent guess (I guess)
173
+ k = k.decode("latin-1", "replace")
174
+ v = v.decode("latin-1", "replace")
175
+
176
+ # Convert value as appropriate
177
+ if k in [FRAMES, SCALE, SIZE]:
178
+ v = v.replace("*", ",")
179
+ v = tuple(map(number, v.split(",")))
180
+ if len(v) == 1:
181
+ v = v[0]
182
+ elif k == MODE and v in OPEN:
183
+ v, self.rawmode = OPEN[v]
184
+
185
+ # Add to dictionary. Note that COMMENT tags are
186
+ # combined into a list of strings.
187
+ if k == COMMENT:
188
+ if k in self.info:
189
+ self.info[k].append(v)
190
+ else:
191
+ self.info[k] = [v]
192
+ else:
193
+ self.info[k] = v
194
+
195
+ if k in TAGS:
196
+ n += 1
197
+
198
+ else:
199
+ msg = "Syntax error in IM header: " + s.decode("ascii", "replace")
200
+ raise SyntaxError(msg)
201
+
202
+ if not n:
203
+ msg = "Not an IM file"
204
+ raise SyntaxError(msg)
205
+
206
+ # Basic attributes
207
+ self._size = self.info[SIZE]
208
+ self._mode = self.info[MODE]
209
+
210
+ # Skip forward to start of image data
211
+ while s and s[:1] != b"\x1A":
212
+ s = self.fp.read(1)
213
+ if not s:
214
+ msg = "File truncated"
215
+ raise SyntaxError(msg)
216
+
217
+ if LUT in self.info:
218
+ # convert lookup table to palette or lut attribute
219
+ palette = self.fp.read(768)
220
+ greyscale = 1 # greyscale palette
221
+ linear = 1 # linear greyscale palette
222
+ for i in range(256):
223
+ if palette[i] == palette[i + 256] == palette[i + 512]:
224
+ if palette[i] != i:
225
+ linear = 0
226
+ else:
227
+ greyscale = 0
228
+ if self.mode in ["L", "LA", "P", "PA"]:
229
+ if greyscale:
230
+ if not linear:
231
+ self.lut = list(palette[:256])
232
+ else:
233
+ if self.mode in ["L", "P"]:
234
+ self._mode = self.rawmode = "P"
235
+ elif self.mode in ["LA", "PA"]:
236
+ self._mode = "PA"
237
+ self.rawmode = "PA;L"
238
+ self.palette = ImagePalette.raw("RGB;L", palette)
239
+ elif self.mode == "RGB":
240
+ if not greyscale or not linear:
241
+ self.lut = list(palette)
242
+
243
+ self.frame = 0
244
+
245
+ self.__offset = offs = self.fp.tell()
246
+
247
+ self._fp = self.fp # FIXME: hack
248
+
249
+ if self.rawmode[:2] == "F;":
250
+ # ifunc95 formats
251
+ try:
252
+ # use bit decoder (if necessary)
253
+ bits = int(self.rawmode[2:])
254
+ if bits not in [8, 16, 32]:
255
+ self.tile = [("bit", (0, 0) + self.size, offs, (bits, 8, 3, 0, -1))]
256
+ return
257
+ except ValueError:
258
+ pass
259
+
260
+ if self.rawmode in ["RGB;T", "RYB;T"]:
261
+ # Old LabEye/3PC files. Would be very surprised if anyone
262
+ # ever stumbled upon such a file ;-)
263
+ size = self.size[0] * self.size[1]
264
+ self.tile = [
265
+ ("raw", (0, 0) + self.size, offs, ("G", 0, -1)),
266
+ ("raw", (0, 0) + self.size, offs + size, ("R", 0, -1)),
267
+ ("raw", (0, 0) + self.size, offs + 2 * size, ("B", 0, -1)),
268
+ ]
269
+ else:
270
+ # LabEye/IFUNC files
271
+ self.tile = [("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))]
272
+
273
+ @property
274
+ def n_frames(self):
275
+ return self.info[FRAMES]
276
+
277
+ @property
278
+ def is_animated(self):
279
+ return self.info[FRAMES] > 1
280
+
281
+ def seek(self, frame):
282
+ if not self._seek_check(frame):
283
+ return
284
+
285
+ self.frame = frame
286
+
287
+ if self.mode == "1":
288
+ bits = 1
289
+ else:
290
+ bits = 8 * len(self.mode)
291
+
292
+ size = ((self.size[0] * bits + 7) // 8) * self.size[1]
293
+ offs = self.__offset + frame * size
294
+
295
+ self.fp = self._fp
296
+
297
+ self.tile = [("raw", (0, 0) + self.size, offs, (self.rawmode, 0, -1))]
298
+
299
+ def tell(self):
300
+ return self.frame
301
+
302
+
303
+ #
304
+ # --------------------------------------------------------------------
305
+ # Save IM files
306
+
307
+
308
+ SAVE = {
309
+ # mode: (im type, raw mode)
310
+ "1": ("0 1", "1"),
311
+ "L": ("Greyscale", "L"),
312
+ "LA": ("LA", "LA;L"),
313
+ "P": ("Greyscale", "P"),
314
+ "PA": ("LA", "PA;L"),
315
+ "I": ("L 32S", "I;32S"),
316
+ "I;16": ("L 16", "I;16"),
317
+ "I;16L": ("L 16L", "I;16L"),
318
+ "I;16B": ("L 16B", "I;16B"),
319
+ "F": ("L 32F", "F;32F"),
320
+ "RGB": ("RGB", "RGB;L"),
321
+ "RGBA": ("RGBA", "RGBA;L"),
322
+ "RGBX": ("RGBX", "RGBX;L"),
323
+ "CMYK": ("CMYK", "CMYK;L"),
324
+ "YCbCr": ("YCC", "YCbCr;L"),
325
+ }
326
+
327
+
328
+ def _save(im, fp, filename):
329
+ try:
330
+ image_type, rawmode = SAVE[im.mode]
331
+ except KeyError as e:
332
+ msg = f"Cannot save {im.mode} images as IM"
333
+ raise ValueError(msg) from e
334
+
335
+ frames = im.encoderinfo.get("frames", 1)
336
+
337
+ fp.write(f"Image type: {image_type} image\r\n".encode("ascii"))
338
+ if filename:
339
+ # Each line must be 100 characters or less,
340
+ # or: SyntaxError("not an IM file")
341
+ # 8 characters are used for "Name: " and "\r\n"
342
+ # Keep just the filename, ditch the potentially overlong path
343
+ name, ext = os.path.splitext(os.path.basename(filename))
344
+ name = "".join([name[: 92 - len(ext)], ext])
345
+
346
+ fp.write(f"Name: {name}\r\n".encode("ascii"))
347
+ fp.write(("Image size (x*y): %d*%d\r\n" % im.size).encode("ascii"))
348
+ fp.write(f"File size (no of images): {frames}\r\n".encode("ascii"))
349
+ if im.mode in ["P", "PA"]:
350
+ fp.write(b"Lut: 1\r\n")
351
+ fp.write(b"\000" * (511 - fp.tell()) + b"\032")
352
+ if im.mode in ["P", "PA"]:
353
+ im_palette = im.im.getpalette("RGB", "RGB;L")
354
+ colors = len(im_palette) // 3
355
+ palette = b""
356
+ for i in range(3):
357
+ palette += im_palette[colors * i : colors * (i + 1)]
358
+ palette += b"\x00" * (256 - colors)
359
+ fp.write(palette) # 768 bytes
360
+ ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, 0, -1))])
361
+
362
+
363
+ #
364
+ # --------------------------------------------------------------------
365
+ # Registry
366
+
367
+
368
+ Image.register_open(ImImageFile.format, ImImageFile)
369
+ Image.register_save(ImImageFile.format, _save)
370
+
371
+ Image.register_extension(ImImageFile.format, ".im")
env/Lib/site-packages/PIL/Image.py ADDED
The diff for this file is too large to render. See raw diff
 
env/Lib/site-packages/PIL/ImageChops.py ADDED
@@ -0,0 +1,303 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library.
3
+ # $Id$
4
+ #
5
+ # standard channel operations
6
+ #
7
+ # History:
8
+ # 1996-03-24 fl Created
9
+ # 1996-08-13 fl Added logical operations (for "1" images)
10
+ # 2000-10-12 fl Added offset method (from Image.py)
11
+ #
12
+ # Copyright (c) 1997-2000 by Secret Labs AB
13
+ # Copyright (c) 1996-2000 by Fredrik Lundh
14
+ #
15
+ # See the README file for information on usage and redistribution.
16
+ #
17
+
18
+ from . import Image
19
+
20
+
21
+ def constant(image, value):
22
+ """Fill a channel with a given grey level.
23
+
24
+ :rtype: :py:class:`~PIL.Image.Image`
25
+ """
26
+
27
+ return Image.new("L", image.size, value)
28
+
29
+
30
+ def duplicate(image):
31
+ """Copy a channel. Alias for :py:meth:`PIL.Image.Image.copy`.
32
+
33
+ :rtype: :py:class:`~PIL.Image.Image`
34
+ """
35
+
36
+ return image.copy()
37
+
38
+
39
+ def invert(image):
40
+ """
41
+ Invert an image (channel). ::
42
+
43
+ out = MAX - image
44
+
45
+ :rtype: :py:class:`~PIL.Image.Image`
46
+ """
47
+
48
+ image.load()
49
+ return image._new(image.im.chop_invert())
50
+
51
+
52
+ def lighter(image1, image2):
53
+ """
54
+ Compares the two images, pixel by pixel, and returns a new image containing
55
+ the lighter values. ::
56
+
57
+ out = max(image1, image2)
58
+
59
+ :rtype: :py:class:`~PIL.Image.Image`
60
+ """
61
+
62
+ image1.load()
63
+ image2.load()
64
+ return image1._new(image1.im.chop_lighter(image2.im))
65
+
66
+
67
+ def darker(image1, image2):
68
+ """
69
+ Compares the two images, pixel by pixel, and returns a new image containing
70
+ the darker values. ::
71
+
72
+ out = min(image1, image2)
73
+
74
+ :rtype: :py:class:`~PIL.Image.Image`
75
+ """
76
+
77
+ image1.load()
78
+ image2.load()
79
+ return image1._new(image1.im.chop_darker(image2.im))
80
+
81
+
82
+ def difference(image1, image2):
83
+ """
84
+ Returns the absolute value of the pixel-by-pixel difference between the two
85
+ images. ::
86
+
87
+ out = abs(image1 - image2)
88
+
89
+ :rtype: :py:class:`~PIL.Image.Image`
90
+ """
91
+
92
+ image1.load()
93
+ image2.load()
94
+ return image1._new(image1.im.chop_difference(image2.im))
95
+
96
+
97
+ def multiply(image1, image2):
98
+ """
99
+ Superimposes two images on top of each other.
100
+
101
+ If you multiply an image with a solid black image, the result is black. If
102
+ you multiply with a solid white image, the image is unaffected. ::
103
+
104
+ out = image1 * image2 / MAX
105
+
106
+ :rtype: :py:class:`~PIL.Image.Image`
107
+ """
108
+
109
+ image1.load()
110
+ image2.load()
111
+ return image1._new(image1.im.chop_multiply(image2.im))
112
+
113
+
114
+ def screen(image1, image2):
115
+ """
116
+ Superimposes two inverted images on top of each other. ::
117
+
118
+ out = MAX - ((MAX - image1) * (MAX - image2) / MAX)
119
+
120
+ :rtype: :py:class:`~PIL.Image.Image`
121
+ """
122
+
123
+ image1.load()
124
+ image2.load()
125
+ return image1._new(image1.im.chop_screen(image2.im))
126
+
127
+
128
+ def soft_light(image1, image2):
129
+ """
130
+ Superimposes two images on top of each other using the Soft Light algorithm
131
+
132
+ :rtype: :py:class:`~PIL.Image.Image`
133
+ """
134
+
135
+ image1.load()
136
+ image2.load()
137
+ return image1._new(image1.im.chop_soft_light(image2.im))
138
+
139
+
140
+ def hard_light(image1, image2):
141
+ """
142
+ Superimposes two images on top of each other using the Hard Light algorithm
143
+
144
+ :rtype: :py:class:`~PIL.Image.Image`
145
+ """
146
+
147
+ image1.load()
148
+ image2.load()
149
+ return image1._new(image1.im.chop_hard_light(image2.im))
150
+
151
+
152
+ def overlay(image1, image2):
153
+ """
154
+ Superimposes two images on top of each other using the Overlay algorithm
155
+
156
+ :rtype: :py:class:`~PIL.Image.Image`
157
+ """
158
+
159
+ image1.load()
160
+ image2.load()
161
+ return image1._new(image1.im.chop_overlay(image2.im))
162
+
163
+
164
+ def add(image1, image2, scale=1.0, offset=0):
165
+ """
166
+ Adds two images, dividing the result by scale and adding the
167
+ offset. If omitted, scale defaults to 1.0, and offset to 0.0. ::
168
+
169
+ out = ((image1 + image2) / scale + offset)
170
+
171
+ :rtype: :py:class:`~PIL.Image.Image`
172
+ """
173
+
174
+ image1.load()
175
+ image2.load()
176
+ return image1._new(image1.im.chop_add(image2.im, scale, offset))
177
+
178
+
179
+ def subtract(image1, image2, scale=1.0, offset=0):
180
+ """
181
+ Subtracts two images, dividing the result by scale and adding the offset.
182
+ If omitted, scale defaults to 1.0, and offset to 0.0. ::
183
+
184
+ out = ((image1 - image2) / scale + offset)
185
+
186
+ :rtype: :py:class:`~PIL.Image.Image`
187
+ """
188
+
189
+ image1.load()
190
+ image2.load()
191
+ return image1._new(image1.im.chop_subtract(image2.im, scale, offset))
192
+
193
+
194
+ def add_modulo(image1, image2):
195
+ """Add two images, without clipping the result. ::
196
+
197
+ out = ((image1 + image2) % MAX)
198
+
199
+ :rtype: :py:class:`~PIL.Image.Image`
200
+ """
201
+
202
+ image1.load()
203
+ image2.load()
204
+ return image1._new(image1.im.chop_add_modulo(image2.im))
205
+
206
+
207
+ def subtract_modulo(image1, image2):
208
+ """Subtract two images, without clipping the result. ::
209
+
210
+ out = ((image1 - image2) % MAX)
211
+
212
+ :rtype: :py:class:`~PIL.Image.Image`
213
+ """
214
+
215
+ image1.load()
216
+ image2.load()
217
+ return image1._new(image1.im.chop_subtract_modulo(image2.im))
218
+
219
+
220
+ def logical_and(image1, image2):
221
+ """Logical AND between two images.
222
+
223
+ Both of the images must have mode "1". If you would like to perform a
224
+ logical AND on an image with a mode other than "1", try
225
+ :py:meth:`~PIL.ImageChops.multiply` instead, using a black-and-white mask
226
+ as the second image. ::
227
+
228
+ out = ((image1 and image2) % MAX)
229
+
230
+ :rtype: :py:class:`~PIL.Image.Image`
231
+ """
232
+
233
+ image1.load()
234
+ image2.load()
235
+ return image1._new(image1.im.chop_and(image2.im))
236
+
237
+
238
+ def logical_or(image1, image2):
239
+ """Logical OR between two images.
240
+
241
+ Both of the images must have mode "1". ::
242
+
243
+ out = ((image1 or image2) % MAX)
244
+
245
+ :rtype: :py:class:`~PIL.Image.Image`
246
+ """
247
+
248
+ image1.load()
249
+ image2.load()
250
+ return image1._new(image1.im.chop_or(image2.im))
251
+
252
+
253
+ def logical_xor(image1, image2):
254
+ """Logical XOR between two images.
255
+
256
+ Both of the images must have mode "1". ::
257
+
258
+ out = ((bool(image1) != bool(image2)) % MAX)
259
+
260
+ :rtype: :py:class:`~PIL.Image.Image`
261
+ """
262
+
263
+ image1.load()
264
+ image2.load()
265
+ return image1._new(image1.im.chop_xor(image2.im))
266
+
267
+
268
+ def blend(image1, image2, alpha):
269
+ """Blend images using constant transparency weight. Alias for
270
+ :py:func:`PIL.Image.blend`.
271
+
272
+ :rtype: :py:class:`~PIL.Image.Image`
273
+ """
274
+
275
+ return Image.blend(image1, image2, alpha)
276
+
277
+
278
+ def composite(image1, image2, mask):
279
+ """Create composite using transparency mask. Alias for
280
+ :py:func:`PIL.Image.composite`.
281
+
282
+ :rtype: :py:class:`~PIL.Image.Image`
283
+ """
284
+
285
+ return Image.composite(image1, image2, mask)
286
+
287
+
288
+ def offset(image, xoffset, yoffset=None):
289
+ """Returns a copy of the image where data has been offset by the given
290
+ distances. Data wraps around the edges. If ``yoffset`` is omitted, it
291
+ is assumed to be equal to ``xoffset``.
292
+
293
+ :param image: Input image.
294
+ :param xoffset: The horizontal distance.
295
+ :param yoffset: The vertical distance. If omitted, both
296
+ distances are set to the same value.
297
+ :rtype: :py:class:`~PIL.Image.Image`
298
+ """
299
+
300
+ if yoffset is None:
301
+ yoffset = xoffset
302
+ image.load()
303
+ return image._new(image.im.offset(xoffset, yoffset))
env/Lib/site-packages/PIL/ImageCms.py ADDED
@@ -0,0 +1,1009 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # The Python Imaging Library.
2
+ # $Id$
3
+
4
+ # Optional color management support, based on Kevin Cazabon's PyCMS
5
+ # library.
6
+
7
+ # History:
8
+
9
+ # 2009-03-08 fl Added to PIL.
10
+
11
+ # Copyright (C) 2002-2003 Kevin Cazabon
12
+ # Copyright (c) 2009 by Fredrik Lundh
13
+ # Copyright (c) 2013 by Eric Soroos
14
+
15
+ # See the README file for information on usage and redistribution. See
16
+ # below for the original description.
17
+
18
+ import sys
19
+ from enum import IntEnum
20
+
21
+ from . import Image
22
+
23
+ try:
24
+ from . import _imagingcms
25
+ except ImportError as ex:
26
+ # Allow error import for doc purposes, but error out when accessing
27
+ # anything in core.
28
+ from ._util import DeferredError
29
+
30
+ _imagingcms = DeferredError(ex)
31
+
32
+ DESCRIPTION = """
33
+ pyCMS
34
+
35
+ a Python / PIL interface to the littleCMS ICC Color Management System
36
+ Copyright (C) 2002-2003 Kevin Cazabon
37
38
+ https://www.cazabon.com
39
+
40
+ pyCMS home page: https://www.cazabon.com/pyCMS
41
+ littleCMS home page: https://www.littlecms.com
42
+ (littleCMS is Copyright (C) 1998-2001 Marti Maria)
43
+
44
+ Originally released under LGPL. Graciously donated to PIL in
45
+ March 2009, for distribution under the standard PIL license
46
+
47
+ The pyCMS.py module provides a "clean" interface between Python/PIL and
48
+ pyCMSdll, taking care of some of the more complex handling of the direct
49
+ pyCMSdll functions, as well as error-checking and making sure that all
50
+ relevant data is kept together.
51
+
52
+ While it is possible to call pyCMSdll functions directly, it's not highly
53
+ recommended.
54
+
55
+ Version History:
56
+
57
+ 1.0.0 pil Oct 2013 Port to LCMS 2.
58
+
59
+ 0.1.0 pil mod March 10, 2009
60
+
61
+ Renamed display profile to proof profile. The proof
62
+ profile is the profile of the device that is being
63
+ simulated, not the profile of the device which is
64
+ actually used to display/print the final simulation
65
+ (that'd be the output profile) - also see LCMSAPI.txt
66
+ input colorspace -> using 'renderingIntent' -> proof
67
+ colorspace -> using 'proofRenderingIntent' -> output
68
+ colorspace
69
+
70
+ Added LCMS FLAGS support.
71
+ Added FLAGS["SOFTPROOFING"] as default flag for
72
+ buildProofTransform (otherwise the proof profile/intent
73
+ would be ignored).
74
+
75
+ 0.1.0 pil March 2009 - added to PIL, as PIL.ImageCms
76
+
77
+ 0.0.2 alpha Jan 6, 2002
78
+
79
+ Added try/except statements around type() checks of
80
+ potential CObjects... Python won't let you use type()
81
+ on them, and raises a TypeError (stupid, if you ask
82
+ me!)
83
+
84
+ Added buildProofTransformFromOpenProfiles() function.
85
+ Additional fixes in DLL, see DLL code for details.
86
+
87
+ 0.0.1 alpha first public release, Dec. 26, 2002
88
+
89
+ Known to-do list with current version (of Python interface, not pyCMSdll):
90
+
91
+ none
92
+
93
+ """
94
+
95
+ VERSION = "1.0.0 pil"
96
+
97
+ # --------------------------------------------------------------------.
98
+
99
+ core = _imagingcms
100
+
101
+ #
102
+ # intent/direction values
103
+
104
+
105
+ class Intent(IntEnum):
106
+ PERCEPTUAL = 0
107
+ RELATIVE_COLORIMETRIC = 1
108
+ SATURATION = 2
109
+ ABSOLUTE_COLORIMETRIC = 3
110
+
111
+
112
+ class Direction(IntEnum):
113
+ INPUT = 0
114
+ OUTPUT = 1
115
+ PROOF = 2
116
+
117
+
118
+ #
119
+ # flags
120
+
121
+ FLAGS = {
122
+ "MATRIXINPUT": 1,
123
+ "MATRIXOUTPUT": 2,
124
+ "MATRIXONLY": (1 | 2),
125
+ "NOWHITEONWHITEFIXUP": 4, # Don't hot fix scum dot
126
+ # Don't create prelinearization tables on precalculated transforms
127
+ # (internal use):
128
+ "NOPRELINEARIZATION": 16,
129
+ "GUESSDEVICECLASS": 32, # Guess device class (for transform2devicelink)
130
+ "NOTCACHE": 64, # Inhibit 1-pixel cache
131
+ "NOTPRECALC": 256,
132
+ "NULLTRANSFORM": 512, # Don't transform anyway
133
+ "HIGHRESPRECALC": 1024, # Use more memory to give better accuracy
134
+ "LOWRESPRECALC": 2048, # Use less memory to minimize resources
135
+ "WHITEBLACKCOMPENSATION": 8192,
136
+ "BLACKPOINTCOMPENSATION": 8192,
137
+ "GAMUTCHECK": 4096, # Out of Gamut alarm
138
+ "SOFTPROOFING": 16384, # Do softproofing
139
+ "PRESERVEBLACK": 32768, # Black preservation
140
+ "NODEFAULTRESOURCEDEF": 16777216, # CRD special
141
+ "GRIDPOINTS": lambda n: (n & 0xFF) << 16, # Gridpoints
142
+ }
143
+
144
+ _MAX_FLAG = 0
145
+ for flag in FLAGS.values():
146
+ if isinstance(flag, int):
147
+ _MAX_FLAG = _MAX_FLAG | flag
148
+
149
+
150
+ # --------------------------------------------------------------------.
151
+ # Experimental PIL-level API
152
+ # --------------------------------------------------------------------.
153
+
154
+ ##
155
+ # Profile.
156
+
157
+
158
+ class ImageCmsProfile:
159
+ def __init__(self, profile):
160
+ """
161
+ :param profile: Either a string representing a filename,
162
+ a file like object containing a profile or a
163
+ low-level profile object
164
+
165
+ """
166
+
167
+ if isinstance(profile, str):
168
+ if sys.platform == "win32":
169
+ profile_bytes_path = profile.encode()
170
+ try:
171
+ profile_bytes_path.decode("ascii")
172
+ except UnicodeDecodeError:
173
+ with open(profile, "rb") as f:
174
+ self._set(core.profile_frombytes(f.read()))
175
+ return
176
+ self._set(core.profile_open(profile), profile)
177
+ elif hasattr(profile, "read"):
178
+ self._set(core.profile_frombytes(profile.read()))
179
+ elif isinstance(profile, _imagingcms.CmsProfile):
180
+ self._set(profile)
181
+ else:
182
+ msg = "Invalid type for Profile"
183
+ raise TypeError(msg)
184
+
185
+ def _set(self, profile, filename=None):
186
+ self.profile = profile
187
+ self.filename = filename
188
+ self.product_name = None # profile.product_name
189
+ self.product_info = None # profile.product_info
190
+
191
+ def tobytes(self):
192
+ """
193
+ Returns the profile in a format suitable for embedding in
194
+ saved images.
195
+
196
+ :returns: a bytes object containing the ICC profile.
197
+ """
198
+
199
+ return core.profile_tobytes(self.profile)
200
+
201
+
202
+ class ImageCmsTransform(Image.ImagePointHandler):
203
+
204
+ """
205
+ Transform. This can be used with the procedural API, or with the standard
206
+ :py:func:`~PIL.Image.Image.point` method.
207
+
208
+ Will return the output profile in the ``output.info['icc_profile']``.
209
+ """
210
+
211
+ def __init__(
212
+ self,
213
+ input,
214
+ output,
215
+ input_mode,
216
+ output_mode,
217
+ intent=Intent.PERCEPTUAL,
218
+ proof=None,
219
+ proof_intent=Intent.ABSOLUTE_COLORIMETRIC,
220
+ flags=0,
221
+ ):
222
+ if proof is None:
223
+ self.transform = core.buildTransform(
224
+ input.profile, output.profile, input_mode, output_mode, intent, flags
225
+ )
226
+ else:
227
+ self.transform = core.buildProofTransform(
228
+ input.profile,
229
+ output.profile,
230
+ proof.profile,
231
+ input_mode,
232
+ output_mode,
233
+ intent,
234
+ proof_intent,
235
+ flags,
236
+ )
237
+ # Note: inputMode and outputMode are for pyCMS compatibility only
238
+ self.input_mode = self.inputMode = input_mode
239
+ self.output_mode = self.outputMode = output_mode
240
+
241
+ self.output_profile = output
242
+
243
+ def point(self, im):
244
+ return self.apply(im)
245
+
246
+ def apply(self, im, imOut=None):
247
+ im.load()
248
+ if imOut is None:
249
+ imOut = Image.new(self.output_mode, im.size, None)
250
+ self.transform.apply(im.im.id, imOut.im.id)
251
+ imOut.info["icc_profile"] = self.output_profile.tobytes()
252
+ return imOut
253
+
254
+ def apply_in_place(self, im):
255
+ im.load()
256
+ if im.mode != self.output_mode:
257
+ msg = "mode mismatch"
258
+ raise ValueError(msg) # wrong output mode
259
+ self.transform.apply(im.im.id, im.im.id)
260
+ im.info["icc_profile"] = self.output_profile.tobytes()
261
+ return im
262
+
263
+
264
+ def get_display_profile(handle=None):
265
+ """
266
+ (experimental) Fetches the profile for the current display device.
267
+
268
+ :returns: ``None`` if the profile is not known.
269
+ """
270
+
271
+ if sys.platform != "win32":
272
+ return None
273
+
274
+ from . import ImageWin
275
+
276
+ if isinstance(handle, ImageWin.HDC):
277
+ profile = core.get_display_profile_win32(handle, 1)
278
+ else:
279
+ profile = core.get_display_profile_win32(handle or 0)
280
+ if profile is None:
281
+ return None
282
+ return ImageCmsProfile(profile)
283
+
284
+
285
+ # --------------------------------------------------------------------.
286
+ # pyCMS compatible layer
287
+ # --------------------------------------------------------------------.
288
+
289
+
290
+ class PyCMSError(Exception):
291
+
292
+ """(pyCMS) Exception class.
293
+ This is used for all errors in the pyCMS API."""
294
+
295
+ pass
296
+
297
+
298
+ def profileToProfile(
299
+ im,
300
+ inputProfile,
301
+ outputProfile,
302
+ renderingIntent=Intent.PERCEPTUAL,
303
+ outputMode=None,
304
+ inPlace=False,
305
+ flags=0,
306
+ ):
307
+ """
308
+ (pyCMS) Applies an ICC transformation to a given image, mapping from
309
+ ``inputProfile`` to ``outputProfile``.
310
+
311
+ If the input or output profiles specified are not valid filenames, a
312
+ :exc:`PyCMSError` will be raised. If ``inPlace`` is ``True`` and
313
+ ``outputMode != im.mode``, a :exc:`PyCMSError` will be raised.
314
+ If an error occurs during application of the profiles,
315
+ a :exc:`PyCMSError` will be raised.
316
+ If ``outputMode`` is not a mode supported by the ``outputProfile`` (or by pyCMS),
317
+ a :exc:`PyCMSError` will be raised.
318
+
319
+ This function applies an ICC transformation to im from ``inputProfile``'s
320
+ color space to ``outputProfile``'s color space using the specified rendering
321
+ intent to decide how to handle out-of-gamut colors.
322
+
323
+ ``outputMode`` can be used to specify that a color mode conversion is to
324
+ be done using these profiles, but the specified profiles must be able
325
+ to handle that mode. I.e., if converting im from RGB to CMYK using
326
+ profiles, the input profile must handle RGB data, and the output
327
+ profile must handle CMYK data.
328
+
329
+ :param im: An open :py:class:`~PIL.Image.Image` object (i.e. Image.new(...)
330
+ or Image.open(...), etc.)
331
+ :param inputProfile: String, as a valid filename path to the ICC input
332
+ profile you wish to use for this image, or a profile object
333
+ :param outputProfile: String, as a valid filename path to the ICC output
334
+ profile you wish to use for this image, or a profile object
335
+ :param renderingIntent: Integer (0-3) specifying the rendering intent you
336
+ wish to use for the transform
337
+
338
+ ImageCms.Intent.PERCEPTUAL = 0 (DEFAULT)
339
+ ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
340
+ ImageCms.Intent.SATURATION = 2
341
+ ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
342
+
343
+ see the pyCMS documentation for details on rendering intents and what
344
+ they do.
345
+ :param outputMode: A valid PIL mode for the output image (i.e. "RGB",
346
+ "CMYK", etc.). Note: if rendering the image "inPlace", outputMode
347
+ MUST be the same mode as the input, or omitted completely. If
348
+ omitted, the outputMode will be the same as the mode of the input
349
+ image (im.mode)
350
+ :param inPlace: Boolean. If ``True``, the original image is modified in-place,
351
+ and ``None`` is returned. If ``False`` (default), a new
352
+ :py:class:`~PIL.Image.Image` object is returned with the transform applied.
353
+ :param flags: Integer (0-...) specifying additional flags
354
+ :returns: Either None or a new :py:class:`~PIL.Image.Image` object, depending on
355
+ the value of ``inPlace``
356
+ :exception PyCMSError:
357
+ """
358
+
359
+ if outputMode is None:
360
+ outputMode = im.mode
361
+
362
+ if not isinstance(renderingIntent, int) or not (0 <= renderingIntent <= 3):
363
+ msg = "renderingIntent must be an integer between 0 and 3"
364
+ raise PyCMSError(msg)
365
+
366
+ if not isinstance(flags, int) or not (0 <= flags <= _MAX_FLAG):
367
+ msg = f"flags must be an integer between 0 and {_MAX_FLAG}"
368
+ raise PyCMSError(msg)
369
+
370
+ try:
371
+ if not isinstance(inputProfile, ImageCmsProfile):
372
+ inputProfile = ImageCmsProfile(inputProfile)
373
+ if not isinstance(outputProfile, ImageCmsProfile):
374
+ outputProfile = ImageCmsProfile(outputProfile)
375
+ transform = ImageCmsTransform(
376
+ inputProfile,
377
+ outputProfile,
378
+ im.mode,
379
+ outputMode,
380
+ renderingIntent,
381
+ flags=flags,
382
+ )
383
+ if inPlace:
384
+ transform.apply_in_place(im)
385
+ imOut = None
386
+ else:
387
+ imOut = transform.apply(im)
388
+ except (OSError, TypeError, ValueError) as v:
389
+ raise PyCMSError(v) from v
390
+
391
+ return imOut
392
+
393
+
394
+ def getOpenProfile(profileFilename):
395
+ """
396
+ (pyCMS) Opens an ICC profile file.
397
+
398
+ The PyCMSProfile object can be passed back into pyCMS for use in creating
399
+ transforms and such (as in ImageCms.buildTransformFromOpenProfiles()).
400
+
401
+ If ``profileFilename`` is not a valid filename for an ICC profile,
402
+ a :exc:`PyCMSError` will be raised.
403
+
404
+ :param profileFilename: String, as a valid filename path to the ICC profile
405
+ you wish to open, or a file-like object.
406
+ :returns: A CmsProfile class object.
407
+ :exception PyCMSError:
408
+ """
409
+
410
+ try:
411
+ return ImageCmsProfile(profileFilename)
412
+ except (OSError, TypeError, ValueError) as v:
413
+ raise PyCMSError(v) from v
414
+
415
+
416
+ def buildTransform(
417
+ inputProfile,
418
+ outputProfile,
419
+ inMode,
420
+ outMode,
421
+ renderingIntent=Intent.PERCEPTUAL,
422
+ flags=0,
423
+ ):
424
+ """
425
+ (pyCMS) Builds an ICC transform mapping from the ``inputProfile`` to the
426
+ ``outputProfile``. Use applyTransform to apply the transform to a given
427
+ image.
428
+
429
+ If the input or output profiles specified are not valid filenames, a
430
+ :exc:`PyCMSError` will be raised. If an error occurs during creation
431
+ of the transform, a :exc:`PyCMSError` will be raised.
432
+
433
+ If ``inMode`` or ``outMode`` are not a mode supported by the ``outputProfile``
434
+ (or by pyCMS), a :exc:`PyCMSError` will be raised.
435
+
436
+ This function builds and returns an ICC transform from the ``inputProfile``
437
+ to the ``outputProfile`` using the ``renderingIntent`` to determine what to do
438
+ with out-of-gamut colors. It will ONLY work for converting images that
439
+ are in ``inMode`` to images that are in ``outMode`` color format (PIL mode,
440
+ i.e. "RGB", "RGBA", "CMYK", etc.).
441
+
442
+ Building the transform is a fair part of the overhead in
443
+ ImageCms.profileToProfile(), so if you're planning on converting multiple
444
+ images using the same input/output settings, this can save you time.
445
+ Once you have a transform object, it can be used with
446
+ ImageCms.applyProfile() to convert images without the need to re-compute
447
+ the lookup table for the transform.
448
+
449
+ The reason pyCMS returns a class object rather than a handle directly
450
+ to the transform is that it needs to keep track of the PIL input/output
451
+ modes that the transform is meant for. These attributes are stored in
452
+ the ``inMode`` and ``outMode`` attributes of the object (which can be
453
+ manually overridden if you really want to, but I don't know of any
454
+ time that would be of use, or would even work).
455
+
456
+ :param inputProfile: String, as a valid filename path to the ICC input
457
+ profile you wish to use for this transform, or a profile object
458
+ :param outputProfile: String, as a valid filename path to the ICC output
459
+ profile you wish to use for this transform, or a profile object
460
+ :param inMode: String, as a valid PIL mode that the appropriate profile
461
+ also supports (i.e. "RGB", "RGBA", "CMYK", etc.)
462
+ :param outMode: String, as a valid PIL mode that the appropriate profile
463
+ also supports (i.e. "RGB", "RGBA", "CMYK", etc.)
464
+ :param renderingIntent: Integer (0-3) specifying the rendering intent you
465
+ wish to use for the transform
466
+
467
+ ImageCms.Intent.PERCEPTUAL = 0 (DEFAULT)
468
+ ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
469
+ ImageCms.Intent.SATURATION = 2
470
+ ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
471
+
472
+ see the pyCMS documentation for details on rendering intents and what
473
+ they do.
474
+ :param flags: Integer (0-...) specifying additional flags
475
+ :returns: A CmsTransform class object.
476
+ :exception PyCMSError:
477
+ """
478
+
479
+ if not isinstance(renderingIntent, int) or not (0 <= renderingIntent <= 3):
480
+ msg = "renderingIntent must be an integer between 0 and 3"
481
+ raise PyCMSError(msg)
482
+
483
+ if not isinstance(flags, int) or not (0 <= flags <= _MAX_FLAG):
484
+ msg = "flags must be an integer between 0 and %s" + _MAX_FLAG
485
+ raise PyCMSError(msg)
486
+
487
+ try:
488
+ if not isinstance(inputProfile, ImageCmsProfile):
489
+ inputProfile = ImageCmsProfile(inputProfile)
490
+ if not isinstance(outputProfile, ImageCmsProfile):
491
+ outputProfile = ImageCmsProfile(outputProfile)
492
+ return ImageCmsTransform(
493
+ inputProfile, outputProfile, inMode, outMode, renderingIntent, flags=flags
494
+ )
495
+ except (OSError, TypeError, ValueError) as v:
496
+ raise PyCMSError(v) from v
497
+
498
+
499
+ def buildProofTransform(
500
+ inputProfile,
501
+ outputProfile,
502
+ proofProfile,
503
+ inMode,
504
+ outMode,
505
+ renderingIntent=Intent.PERCEPTUAL,
506
+ proofRenderingIntent=Intent.ABSOLUTE_COLORIMETRIC,
507
+ flags=FLAGS["SOFTPROOFING"],
508
+ ):
509
+ """
510
+ (pyCMS) Builds an ICC transform mapping from the ``inputProfile`` to the
511
+ ``outputProfile``, but tries to simulate the result that would be
512
+ obtained on the ``proofProfile`` device.
513
+
514
+ If the input, output, or proof profiles specified are not valid
515
+ filenames, a :exc:`PyCMSError` will be raised.
516
+
517
+ If an error occurs during creation of the transform,
518
+ a :exc:`PyCMSError` will be raised.
519
+
520
+ If ``inMode`` or ``outMode`` are not a mode supported by the ``outputProfile``
521
+ (or by pyCMS), a :exc:`PyCMSError` will be raised.
522
+
523
+ This function builds and returns an ICC transform from the ``inputProfile``
524
+ to the ``outputProfile``, but tries to simulate the result that would be
525
+ obtained on the ``proofProfile`` device using ``renderingIntent`` and
526
+ ``proofRenderingIntent`` to determine what to do with out-of-gamut
527
+ colors. This is known as "soft-proofing". It will ONLY work for
528
+ converting images that are in ``inMode`` to images that are in outMode
529
+ color format (PIL mode, i.e. "RGB", "RGBA", "CMYK", etc.).
530
+
531
+ Usage of the resulting transform object is exactly the same as with
532
+ ImageCms.buildTransform().
533
+
534
+ Proof profiling is generally used when using an output device to get a
535
+ good idea of what the final printed/displayed image would look like on
536
+ the ``proofProfile`` device when it's quicker and easier to use the
537
+ output device for judging color. Generally, this means that the
538
+ output device is a monitor, or a dye-sub printer (etc.), and the simulated
539
+ device is something more expensive, complicated, or time consuming
540
+ (making it difficult to make a real print for color judgement purposes).
541
+
542
+ Soft-proofing basically functions by adjusting the colors on the
543
+ output device to match the colors of the device being simulated. However,
544
+ when the simulated device has a much wider gamut than the output
545
+ device, you may obtain marginal results.
546
+
547
+ :param inputProfile: String, as a valid filename path to the ICC input
548
+ profile you wish to use for this transform, or a profile object
549
+ :param outputProfile: String, as a valid filename path to the ICC output
550
+ (monitor, usually) profile you wish to use for this transform, or a
551
+ profile object
552
+ :param proofProfile: String, as a valid filename path to the ICC proof
553
+ profile you wish to use for this transform, or a profile object
554
+ :param inMode: String, as a valid PIL mode that the appropriate profile
555
+ also supports (i.e. "RGB", "RGBA", "CMYK", etc.)
556
+ :param outMode: String, as a valid PIL mode that the appropriate profile
557
+ also supports (i.e. "RGB", "RGBA", "CMYK", etc.)
558
+ :param renderingIntent: Integer (0-3) specifying the rendering intent you
559
+ wish to use for the input->proof (simulated) transform
560
+
561
+ ImageCms.Intent.PERCEPTUAL = 0 (DEFAULT)
562
+ ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
563
+ ImageCms.Intent.SATURATION = 2
564
+ ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
565
+
566
+ see the pyCMS documentation for details on rendering intents and what
567
+ they do.
568
+ :param proofRenderingIntent: Integer (0-3) specifying the rendering intent
569
+ you wish to use for proof->output transform
570
+
571
+ ImageCms.Intent.PERCEPTUAL = 0 (DEFAULT)
572
+ ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
573
+ ImageCms.Intent.SATURATION = 2
574
+ ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
575
+
576
+ see the pyCMS documentation for details on rendering intents and what
577
+ they do.
578
+ :param flags: Integer (0-...) specifying additional flags
579
+ :returns: A CmsTransform class object.
580
+ :exception PyCMSError:
581
+ """
582
+
583
+ if not isinstance(renderingIntent, int) or not (0 <= renderingIntent <= 3):
584
+ msg = "renderingIntent must be an integer between 0 and 3"
585
+ raise PyCMSError(msg)
586
+
587
+ if not isinstance(flags, int) or not (0 <= flags <= _MAX_FLAG):
588
+ msg = "flags must be an integer between 0 and %s" + _MAX_FLAG
589
+ raise PyCMSError(msg)
590
+
591
+ try:
592
+ if not isinstance(inputProfile, ImageCmsProfile):
593
+ inputProfile = ImageCmsProfile(inputProfile)
594
+ if not isinstance(outputProfile, ImageCmsProfile):
595
+ outputProfile = ImageCmsProfile(outputProfile)
596
+ if not isinstance(proofProfile, ImageCmsProfile):
597
+ proofProfile = ImageCmsProfile(proofProfile)
598
+ return ImageCmsTransform(
599
+ inputProfile,
600
+ outputProfile,
601
+ inMode,
602
+ outMode,
603
+ renderingIntent,
604
+ proofProfile,
605
+ proofRenderingIntent,
606
+ flags,
607
+ )
608
+ except (OSError, TypeError, ValueError) as v:
609
+ raise PyCMSError(v) from v
610
+
611
+
612
+ buildTransformFromOpenProfiles = buildTransform
613
+ buildProofTransformFromOpenProfiles = buildProofTransform
614
+
615
+
616
+ def applyTransform(im, transform, inPlace=False):
617
+ """
618
+ (pyCMS) Applies a transform to a given image.
619
+
620
+ If ``im.mode != transform.inMode``, a :exc:`PyCMSError` is raised.
621
+
622
+ If ``inPlace`` is ``True`` and ``transform.inMode != transform.outMode``, a
623
+ :exc:`PyCMSError` is raised.
624
+
625
+ If ``im.mode``, ``transform.inMode`` or ``transform.outMode`` is not
626
+ supported by pyCMSdll or the profiles you used for the transform, a
627
+ :exc:`PyCMSError` is raised.
628
+
629
+ If an error occurs while the transform is being applied,
630
+ a :exc:`PyCMSError` is raised.
631
+
632
+ This function applies a pre-calculated transform (from
633
+ ImageCms.buildTransform() or ImageCms.buildTransformFromOpenProfiles())
634
+ to an image. The transform can be used for multiple images, saving
635
+ considerable calculation time if doing the same conversion multiple times.
636
+
637
+ If you want to modify im in-place instead of receiving a new image as
638
+ the return value, set ``inPlace`` to ``True``. This can only be done if
639
+ ``transform.inMode`` and ``transform.outMode`` are the same, because we can't
640
+ change the mode in-place (the buffer sizes for some modes are
641
+ different). The default behavior is to return a new :py:class:`~PIL.Image.Image`
642
+ object of the same dimensions in mode ``transform.outMode``.
643
+
644
+ :param im: An :py:class:`~PIL.Image.Image` object, and im.mode must be the same
645
+ as the ``inMode`` supported by the transform.
646
+ :param transform: A valid CmsTransform class object
647
+ :param inPlace: Bool. If ``True``, ``im`` is modified in place and ``None`` is
648
+ returned, if ``False``, a new :py:class:`~PIL.Image.Image` object with the
649
+ transform applied is returned (and ``im`` is not changed). The default is
650
+ ``False``.
651
+ :returns: Either ``None``, or a new :py:class:`~PIL.Image.Image` object,
652
+ depending on the value of ``inPlace``. The profile will be returned in
653
+ the image's ``info['icc_profile']``.
654
+ :exception PyCMSError:
655
+ """
656
+
657
+ try:
658
+ if inPlace:
659
+ transform.apply_in_place(im)
660
+ imOut = None
661
+ else:
662
+ imOut = transform.apply(im)
663
+ except (TypeError, ValueError) as v:
664
+ raise PyCMSError(v) from v
665
+
666
+ return imOut
667
+
668
+
669
+ def createProfile(colorSpace, colorTemp=-1):
670
+ """
671
+ (pyCMS) Creates a profile.
672
+
673
+ If colorSpace not in ``["LAB", "XYZ", "sRGB"]``,
674
+ a :exc:`PyCMSError` is raised.
675
+
676
+ If using LAB and ``colorTemp`` is not a positive integer,
677
+ a :exc:`PyCMSError` is raised.
678
+
679
+ If an error occurs while creating the profile,
680
+ a :exc:`PyCMSError` is raised.
681
+
682
+ Use this function to create common profiles on-the-fly instead of
683
+ having to supply a profile on disk and knowing the path to it. It
684
+ returns a normal CmsProfile object that can be passed to
685
+ ImageCms.buildTransformFromOpenProfiles() to create a transform to apply
686
+ to images.
687
+
688
+ :param colorSpace: String, the color space of the profile you wish to
689
+ create.
690
+ Currently only "LAB", "XYZ", and "sRGB" are supported.
691
+ :param colorTemp: Positive integer for the white point for the profile, in
692
+ degrees Kelvin (i.e. 5000, 6500, 9600, etc.). The default is for D50
693
+ illuminant if omitted (5000k). colorTemp is ONLY applied to LAB
694
+ profiles, and is ignored for XYZ and sRGB.
695
+ :returns: A CmsProfile class object
696
+ :exception PyCMSError:
697
+ """
698
+
699
+ if colorSpace not in ["LAB", "XYZ", "sRGB"]:
700
+ msg = (
701
+ f"Color space not supported for on-the-fly profile creation ({colorSpace})"
702
+ )
703
+ raise PyCMSError(msg)
704
+
705
+ if colorSpace == "LAB":
706
+ try:
707
+ colorTemp = float(colorTemp)
708
+ except (TypeError, ValueError) as e:
709
+ msg = f'Color temperature must be numeric, "{colorTemp}" not valid'
710
+ raise PyCMSError(msg) from e
711
+
712
+ try:
713
+ return core.createProfile(colorSpace, colorTemp)
714
+ except (TypeError, ValueError) as v:
715
+ raise PyCMSError(v) from v
716
+
717
+
718
+ def getProfileName(profile):
719
+ """
720
+
721
+ (pyCMS) Gets the internal product name for the given profile.
722
+
723
+ If ``profile`` isn't a valid CmsProfile object or filename to a profile,
724
+ a :exc:`PyCMSError` is raised If an error occurs while trying
725
+ to obtain the name tag, a :exc:`PyCMSError` is raised.
726
+
727
+ Use this function to obtain the INTERNAL name of the profile (stored
728
+ in an ICC tag in the profile itself), usually the one used when the
729
+ profile was originally created. Sometimes this tag also contains
730
+ additional information supplied by the creator.
731
+
732
+ :param profile: EITHER a valid CmsProfile object, OR a string of the
733
+ filename of an ICC profile.
734
+ :returns: A string containing the internal name of the profile as stored
735
+ in an ICC tag.
736
+ :exception PyCMSError:
737
+ """
738
+
739
+ try:
740
+ # add an extra newline to preserve pyCMS compatibility
741
+ if not isinstance(profile, ImageCmsProfile):
742
+ profile = ImageCmsProfile(profile)
743
+ # do it in python, not c.
744
+ # // name was "%s - %s" (model, manufacturer) || Description ,
745
+ # // but if the Model and Manufacturer were the same or the model
746
+ # // was long, Just the model, in 1.x
747
+ model = profile.profile.model
748
+ manufacturer = profile.profile.manufacturer
749
+
750
+ if not (model or manufacturer):
751
+ return (profile.profile.profile_description or "") + "\n"
752
+ if not manufacturer or len(model) > 30:
753
+ return model + "\n"
754
+ return f"{model} - {manufacturer}\n"
755
+
756
+ except (AttributeError, OSError, TypeError, ValueError) as v:
757
+ raise PyCMSError(v) from v
758
+
759
+
760
+ def getProfileInfo(profile):
761
+ """
762
+ (pyCMS) Gets the internal product information for the given profile.
763
+
764
+ If ``profile`` isn't a valid CmsProfile object or filename to a profile,
765
+ a :exc:`PyCMSError` is raised.
766
+
767
+ If an error occurs while trying to obtain the info tag,
768
+ a :exc:`PyCMSError` is raised.
769
+
770
+ Use this function to obtain the information stored in the profile's
771
+ info tag. This often contains details about the profile, and how it
772
+ was created, as supplied by the creator.
773
+
774
+ :param profile: EITHER a valid CmsProfile object, OR a string of the
775
+ filename of an ICC profile.
776
+ :returns: A string containing the internal profile information stored in
777
+ an ICC tag.
778
+ :exception PyCMSError:
779
+ """
780
+
781
+ try:
782
+ if not isinstance(profile, ImageCmsProfile):
783
+ profile = ImageCmsProfile(profile)
784
+ # add an extra newline to preserve pyCMS compatibility
785
+ # Python, not C. the white point bits weren't working well,
786
+ # so skipping.
787
+ # info was description \r\n\r\n copyright \r\n\r\n K007 tag \r\n\r\n whitepoint
788
+ description = profile.profile.profile_description
789
+ cpright = profile.profile.copyright
790
+ arr = []
791
+ for elt in (description, cpright):
792
+ if elt:
793
+ arr.append(elt)
794
+ return "\r\n\r\n".join(arr) + "\r\n\r\n"
795
+
796
+ except (AttributeError, OSError, TypeError, ValueError) as v:
797
+ raise PyCMSError(v) from v
798
+
799
+
800
+ def getProfileCopyright(profile):
801
+ """
802
+ (pyCMS) Gets the copyright for the given profile.
803
+
804
+ If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
805
+ :exc:`PyCMSError` is raised.
806
+
807
+ If an error occurs while trying to obtain the copyright tag,
808
+ a :exc:`PyCMSError` is raised.
809
+
810
+ Use this function to obtain the information stored in the profile's
811
+ copyright tag.
812
+
813
+ :param profile: EITHER a valid CmsProfile object, OR a string of the
814
+ filename of an ICC profile.
815
+ :returns: A string containing the internal profile information stored in
816
+ an ICC tag.
817
+ :exception PyCMSError:
818
+ """
819
+ try:
820
+ # add an extra newline to preserve pyCMS compatibility
821
+ if not isinstance(profile, ImageCmsProfile):
822
+ profile = ImageCmsProfile(profile)
823
+ return (profile.profile.copyright or "") + "\n"
824
+ except (AttributeError, OSError, TypeError, ValueError) as v:
825
+ raise PyCMSError(v) from v
826
+
827
+
828
+ def getProfileManufacturer(profile):
829
+ """
830
+ (pyCMS) Gets the manufacturer for the given profile.
831
+
832
+ If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
833
+ :exc:`PyCMSError` is raised.
834
+
835
+ If an error occurs while trying to obtain the manufacturer tag, a
836
+ :exc:`PyCMSError` is raised.
837
+
838
+ Use this function to obtain the information stored in the profile's
839
+ manufacturer tag.
840
+
841
+ :param profile: EITHER a valid CmsProfile object, OR a string of the
842
+ filename of an ICC profile.
843
+ :returns: A string containing the internal profile information stored in
844
+ an ICC tag.
845
+ :exception PyCMSError:
846
+ """
847
+ try:
848
+ # add an extra newline to preserve pyCMS compatibility
849
+ if not isinstance(profile, ImageCmsProfile):
850
+ profile = ImageCmsProfile(profile)
851
+ return (profile.profile.manufacturer or "") + "\n"
852
+ except (AttributeError, OSError, TypeError, ValueError) as v:
853
+ raise PyCMSError(v) from v
854
+
855
+
856
+ def getProfileModel(profile):
857
+ """
858
+ (pyCMS) Gets the model for the given profile.
859
+
860
+ If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
861
+ :exc:`PyCMSError` is raised.
862
+
863
+ If an error occurs while trying to obtain the model tag,
864
+ a :exc:`PyCMSError` is raised.
865
+
866
+ Use this function to obtain the information stored in the profile's
867
+ model tag.
868
+
869
+ :param profile: EITHER a valid CmsProfile object, OR a string of the
870
+ filename of an ICC profile.
871
+ :returns: A string containing the internal profile information stored in
872
+ an ICC tag.
873
+ :exception PyCMSError:
874
+ """
875
+
876
+ try:
877
+ # add an extra newline to preserve pyCMS compatibility
878
+ if not isinstance(profile, ImageCmsProfile):
879
+ profile = ImageCmsProfile(profile)
880
+ return (profile.profile.model or "") + "\n"
881
+ except (AttributeError, OSError, TypeError, ValueError) as v:
882
+ raise PyCMSError(v) from v
883
+
884
+
885
+ def getProfileDescription(profile):
886
+ """
887
+ (pyCMS) Gets the description for the given profile.
888
+
889
+ If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
890
+ :exc:`PyCMSError` is raised.
891
+
892
+ If an error occurs while trying to obtain the description tag,
893
+ a :exc:`PyCMSError` is raised.
894
+
895
+ Use this function to obtain the information stored in the profile's
896
+ description tag.
897
+
898
+ :param profile: EITHER a valid CmsProfile object, OR a string of the
899
+ filename of an ICC profile.
900
+ :returns: A string containing the internal profile information stored in an
901
+ ICC tag.
902
+ :exception PyCMSError:
903
+ """
904
+
905
+ try:
906
+ # add an extra newline to preserve pyCMS compatibility
907
+ if not isinstance(profile, ImageCmsProfile):
908
+ profile = ImageCmsProfile(profile)
909
+ return (profile.profile.profile_description or "") + "\n"
910
+ except (AttributeError, OSError, TypeError, ValueError) as v:
911
+ raise PyCMSError(v) from v
912
+
913
+
914
+ def getDefaultIntent(profile):
915
+ """
916
+ (pyCMS) Gets the default intent name for the given profile.
917
+
918
+ If ``profile`` isn't a valid CmsProfile object or filename to a profile, a
919
+ :exc:`PyCMSError` is raised.
920
+
921
+ If an error occurs while trying to obtain the default intent, a
922
+ :exc:`PyCMSError` is raised.
923
+
924
+ Use this function to determine the default (and usually best optimized)
925
+ rendering intent for this profile. Most profiles support multiple
926
+ rendering intents, but are intended mostly for one type of conversion.
927
+ If you wish to use a different intent than returned, use
928
+ ImageCms.isIntentSupported() to verify it will work first.
929
+
930
+ :param profile: EITHER a valid CmsProfile object, OR a string of the
931
+ filename of an ICC profile.
932
+ :returns: Integer 0-3 specifying the default rendering intent for this
933
+ profile.
934
+
935
+ ImageCms.Intent.PERCEPTUAL = 0 (DEFAULT)
936
+ ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
937
+ ImageCms.Intent.SATURATION = 2
938
+ ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
939
+
940
+ see the pyCMS documentation for details on rendering intents and what
941
+ they do.
942
+ :exception PyCMSError:
943
+ """
944
+
945
+ try:
946
+ if not isinstance(profile, ImageCmsProfile):
947
+ profile = ImageCmsProfile(profile)
948
+ return profile.profile.rendering_intent
949
+ except (AttributeError, OSError, TypeError, ValueError) as v:
950
+ raise PyCMSError(v) from v
951
+
952
+
953
+ def isIntentSupported(profile, intent, direction):
954
+ """
955
+ (pyCMS) Checks if a given intent is supported.
956
+
957
+ Use this function to verify that you can use your desired
958
+ ``intent`` with ``profile``, and that ``profile`` can be used for the
959
+ input/output/proof profile as you desire.
960
+
961
+ Some profiles are created specifically for one "direction", can cannot
962
+ be used for others. Some profiles can only be used for certain
963
+ rendering intents, so it's best to either verify this before trying
964
+ to create a transform with them (using this function), or catch the
965
+ potential :exc:`PyCMSError` that will occur if they don't
966
+ support the modes you select.
967
+
968
+ :param profile: EITHER a valid CmsProfile object, OR a string of the
969
+ filename of an ICC profile.
970
+ :param intent: Integer (0-3) specifying the rendering intent you wish to
971
+ use with this profile
972
+
973
+ ImageCms.Intent.PERCEPTUAL = 0 (DEFAULT)
974
+ ImageCms.Intent.RELATIVE_COLORIMETRIC = 1
975
+ ImageCms.Intent.SATURATION = 2
976
+ ImageCms.Intent.ABSOLUTE_COLORIMETRIC = 3
977
+
978
+ see the pyCMS documentation for details on rendering intents and what
979
+ they do.
980
+ :param direction: Integer specifying if the profile is to be used for
981
+ input, output, or proof
982
+
983
+ INPUT = 0 (or use ImageCms.Direction.INPUT)
984
+ OUTPUT = 1 (or use ImageCms.Direction.OUTPUT)
985
+ PROOF = 2 (or use ImageCms.Direction.PROOF)
986
+
987
+ :returns: 1 if the intent/direction are supported, -1 if they are not.
988
+ :exception PyCMSError:
989
+ """
990
+
991
+ try:
992
+ if not isinstance(profile, ImageCmsProfile):
993
+ profile = ImageCmsProfile(profile)
994
+ # FIXME: I get different results for the same data w. different
995
+ # compilers. Bug in LittleCMS or in the binding?
996
+ if profile.profile.is_intent_supported(intent, direction):
997
+ return 1
998
+ else:
999
+ return -1
1000
+ except (AttributeError, OSError, TypeError, ValueError) as v:
1001
+ raise PyCMSError(v) from v
1002
+
1003
+
1004
+ def versions():
1005
+ """
1006
+ (pyCMS) Fetches versions.
1007
+ """
1008
+
1009
+ return VERSION, core.littlecms_version, sys.version.split()[0], Image.__version__
env/Lib/site-packages/PIL/ImageColor.py ADDED
@@ -0,0 +1,313 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library
3
+ # $Id$
4
+ #
5
+ # map CSS3-style colour description strings to RGB
6
+ #
7
+ # History:
8
+ # 2002-10-24 fl Added support for CSS-style color strings
9
+ # 2002-12-15 fl Added RGBA support
10
+ # 2004-03-27 fl Fixed remaining int() problems for Python 1.5.2
11
+ # 2004-07-19 fl Fixed gray/grey spelling issues
12
+ # 2009-03-05 fl Fixed rounding error in grayscale calculation
13
+ #
14
+ # Copyright (c) 2002-2004 by Secret Labs AB
15
+ # Copyright (c) 2002-2004 by Fredrik Lundh
16
+ #
17
+ # See the README file for information on usage and redistribution.
18
+ #
19
+
20
+ import re
21
+
22
+ from . import Image
23
+
24
+
25
+ def getrgb(color):
26
+ """
27
+ Convert a color string to an RGB or RGBA tuple. If the string cannot be
28
+ parsed, this function raises a :py:exc:`ValueError` exception.
29
+
30
+ .. versionadded:: 1.1.4
31
+
32
+ :param color: A color string
33
+ :return: ``(red, green, blue[, alpha])``
34
+ """
35
+ if len(color) > 100:
36
+ msg = "color specifier is too long"
37
+ raise ValueError(msg)
38
+ color = color.lower()
39
+
40
+ rgb = colormap.get(color, None)
41
+ if rgb:
42
+ if isinstance(rgb, tuple):
43
+ return rgb
44
+ colormap[color] = rgb = getrgb(rgb)
45
+ return rgb
46
+
47
+ # check for known string formats
48
+ if re.match("#[a-f0-9]{3}$", color):
49
+ return int(color[1] * 2, 16), int(color[2] * 2, 16), int(color[3] * 2, 16)
50
+
51
+ if re.match("#[a-f0-9]{4}$", color):
52
+ return (
53
+ int(color[1] * 2, 16),
54
+ int(color[2] * 2, 16),
55
+ int(color[3] * 2, 16),
56
+ int(color[4] * 2, 16),
57
+ )
58
+
59
+ if re.match("#[a-f0-9]{6}$", color):
60
+ return int(color[1:3], 16), int(color[3:5], 16), int(color[5:7], 16)
61
+
62
+ if re.match("#[a-f0-9]{8}$", color):
63
+ return (
64
+ int(color[1:3], 16),
65
+ int(color[3:5], 16),
66
+ int(color[5:7], 16),
67
+ int(color[7:9], 16),
68
+ )
69
+
70
+ m = re.match(r"rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$", color)
71
+ if m:
72
+ return int(m.group(1)), int(m.group(2)), int(m.group(3))
73
+
74
+ m = re.match(r"rgb\(\s*(\d+)%\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)$", color)
75
+ if m:
76
+ return (
77
+ int((int(m.group(1)) * 255) / 100.0 + 0.5),
78
+ int((int(m.group(2)) * 255) / 100.0 + 0.5),
79
+ int((int(m.group(3)) * 255) / 100.0 + 0.5),
80
+ )
81
+
82
+ m = re.match(
83
+ r"hsl\(\s*(\d+\.?\d*)\s*,\s*(\d+\.?\d*)%\s*,\s*(\d+\.?\d*)%\s*\)$", color
84
+ )
85
+ if m:
86
+ from colorsys import hls_to_rgb
87
+
88
+ rgb = hls_to_rgb(
89
+ float(m.group(1)) / 360.0,
90
+ float(m.group(3)) / 100.0,
91
+ float(m.group(2)) / 100.0,
92
+ )
93
+ return (
94
+ int(rgb[0] * 255 + 0.5),
95
+ int(rgb[1] * 255 + 0.5),
96
+ int(rgb[2] * 255 + 0.5),
97
+ )
98
+
99
+ m = re.match(
100
+ r"hs[bv]\(\s*(\d+\.?\d*)\s*,\s*(\d+\.?\d*)%\s*,\s*(\d+\.?\d*)%\s*\)$", color
101
+ )
102
+ if m:
103
+ from colorsys import hsv_to_rgb
104
+
105
+ rgb = hsv_to_rgb(
106
+ float(m.group(1)) / 360.0,
107
+ float(m.group(2)) / 100.0,
108
+ float(m.group(3)) / 100.0,
109
+ )
110
+ return (
111
+ int(rgb[0] * 255 + 0.5),
112
+ int(rgb[1] * 255 + 0.5),
113
+ int(rgb[2] * 255 + 0.5),
114
+ )
115
+
116
+ m = re.match(r"rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$", color)
117
+ if m:
118
+ return int(m.group(1)), int(m.group(2)), int(m.group(3)), int(m.group(4))
119
+ msg = f"unknown color specifier: {repr(color)}"
120
+ raise ValueError(msg)
121
+
122
+
123
+ def getcolor(color, mode):
124
+ """
125
+ Same as :py:func:`~PIL.ImageColor.getrgb` for most modes. However, if
126
+ ``mode`` is HSV, converts the RGB value to a HSV value, or if ``mode`` is
127
+ not color or a palette image, converts the RGB value to a greyscale value.
128
+ If the string cannot be parsed, this function raises a :py:exc:`ValueError`
129
+ exception.
130
+
131
+ .. versionadded:: 1.1.4
132
+
133
+ :param color: A color string
134
+ :param mode: Convert result to this mode
135
+ :return: ``(graylevel[, alpha]) or (red, green, blue[, alpha])``
136
+ """
137
+ # same as getrgb, but converts the result to the given mode
138
+ color, alpha = getrgb(color), 255
139
+ if len(color) == 4:
140
+ color, alpha = color[:3], color[3]
141
+
142
+ if mode == "HSV":
143
+ from colorsys import rgb_to_hsv
144
+
145
+ r, g, b = color
146
+ h, s, v = rgb_to_hsv(r / 255, g / 255, b / 255)
147
+ return int(h * 255), int(s * 255), int(v * 255)
148
+ elif Image.getmodebase(mode) == "L":
149
+ r, g, b = color
150
+ # ITU-R Recommendation 601-2 for nonlinear RGB
151
+ # scaled to 24 bits to match the convert's implementation.
152
+ color = (r * 19595 + g * 38470 + b * 7471 + 0x8000) >> 16
153
+ if mode[-1] == "A":
154
+ return color, alpha
155
+ else:
156
+ if mode[-1] == "A":
157
+ return color + (alpha,)
158
+ return color
159
+
160
+
161
+ colormap = {
162
+ # X11 colour table from https://drafts.csswg.org/css-color-4/, with
163
+ # gray/grey spelling issues fixed. This is a superset of HTML 4.0
164
+ # colour names used in CSS 1.
165
+ "aliceblue": "#f0f8ff",
166
+ "antiquewhite": "#faebd7",
167
+ "aqua": "#00ffff",
168
+ "aquamarine": "#7fffd4",
169
+ "azure": "#f0ffff",
170
+ "beige": "#f5f5dc",
171
+ "bisque": "#ffe4c4",
172
+ "black": "#000000",
173
+ "blanchedalmond": "#ffebcd",
174
+ "blue": "#0000ff",
175
+ "blueviolet": "#8a2be2",
176
+ "brown": "#a52a2a",
177
+ "burlywood": "#deb887",
178
+ "cadetblue": "#5f9ea0",
179
+ "chartreuse": "#7fff00",
180
+ "chocolate": "#d2691e",
181
+ "coral": "#ff7f50",
182
+ "cornflowerblue": "#6495ed",
183
+ "cornsilk": "#fff8dc",
184
+ "crimson": "#dc143c",
185
+ "cyan": "#00ffff",
186
+ "darkblue": "#00008b",
187
+ "darkcyan": "#008b8b",
188
+ "darkgoldenrod": "#b8860b",
189
+ "darkgray": "#a9a9a9",
190
+ "darkgrey": "#a9a9a9",
191
+ "darkgreen": "#006400",
192
+ "darkkhaki": "#bdb76b",
193
+ "darkmagenta": "#8b008b",
194
+ "darkolivegreen": "#556b2f",
195
+ "darkorange": "#ff8c00",
196
+ "darkorchid": "#9932cc",
197
+ "darkred": "#8b0000",
198
+ "darksalmon": "#e9967a",
199
+ "darkseagreen": "#8fbc8f",
200
+ "darkslateblue": "#483d8b",
201
+ "darkslategray": "#2f4f4f",
202
+ "darkslategrey": "#2f4f4f",
203
+ "darkturquoise": "#00ced1",
204
+ "darkviolet": "#9400d3",
205
+ "deeppink": "#ff1493",
206
+ "deepskyblue": "#00bfff",
207
+ "dimgray": "#696969",
208
+ "dimgrey": "#696969",
209
+ "dodgerblue": "#1e90ff",
210
+ "firebrick": "#b22222",
211
+ "floralwhite": "#fffaf0",
212
+ "forestgreen": "#228b22",
213
+ "fuchsia": "#ff00ff",
214
+ "gainsboro": "#dcdcdc",
215
+ "ghostwhite": "#f8f8ff",
216
+ "gold": "#ffd700",
217
+ "goldenrod": "#daa520",
218
+ "gray": "#808080",
219
+ "grey": "#808080",
220
+ "green": "#008000",
221
+ "greenyellow": "#adff2f",
222
+ "honeydew": "#f0fff0",
223
+ "hotpink": "#ff69b4",
224
+ "indianred": "#cd5c5c",
225
+ "indigo": "#4b0082",
226
+ "ivory": "#fffff0",
227
+ "khaki": "#f0e68c",
228
+ "lavender": "#e6e6fa",
229
+ "lavenderblush": "#fff0f5",
230
+ "lawngreen": "#7cfc00",
231
+ "lemonchiffon": "#fffacd",
232
+ "lightblue": "#add8e6",
233
+ "lightcoral": "#f08080",
234
+ "lightcyan": "#e0ffff",
235
+ "lightgoldenrodyellow": "#fafad2",
236
+ "lightgreen": "#90ee90",
237
+ "lightgray": "#d3d3d3",
238
+ "lightgrey": "#d3d3d3",
239
+ "lightpink": "#ffb6c1",
240
+ "lightsalmon": "#ffa07a",
241
+ "lightseagreen": "#20b2aa",
242
+ "lightskyblue": "#87cefa",
243
+ "lightslategray": "#778899",
244
+ "lightslategrey": "#778899",
245
+ "lightsteelblue": "#b0c4de",
246
+ "lightyellow": "#ffffe0",
247
+ "lime": "#00ff00",
248
+ "limegreen": "#32cd32",
249
+ "linen": "#faf0e6",
250
+ "magenta": "#ff00ff",
251
+ "maroon": "#800000",
252
+ "mediumaquamarine": "#66cdaa",
253
+ "mediumblue": "#0000cd",
254
+ "mediumorchid": "#ba55d3",
255
+ "mediumpurple": "#9370db",
256
+ "mediumseagreen": "#3cb371",
257
+ "mediumslateblue": "#7b68ee",
258
+ "mediumspringgreen": "#00fa9a",
259
+ "mediumturquoise": "#48d1cc",
260
+ "mediumvioletred": "#c71585",
261
+ "midnightblue": "#191970",
262
+ "mintcream": "#f5fffa",
263
+ "mistyrose": "#ffe4e1",
264
+ "moccasin": "#ffe4b5",
265
+ "navajowhite": "#ffdead",
266
+ "navy": "#000080",
267
+ "oldlace": "#fdf5e6",
268
+ "olive": "#808000",
269
+ "olivedrab": "#6b8e23",
270
+ "orange": "#ffa500",
271
+ "orangered": "#ff4500",
272
+ "orchid": "#da70d6",
273
+ "palegoldenrod": "#eee8aa",
274
+ "palegreen": "#98fb98",
275
+ "paleturquoise": "#afeeee",
276
+ "palevioletred": "#db7093",
277
+ "papayawhip": "#ffefd5",
278
+ "peachpuff": "#ffdab9",
279
+ "peru": "#cd853f",
280
+ "pink": "#ffc0cb",
281
+ "plum": "#dda0dd",
282
+ "powderblue": "#b0e0e6",
283
+ "purple": "#800080",
284
+ "rebeccapurple": "#663399",
285
+ "red": "#ff0000",
286
+ "rosybrown": "#bc8f8f",
287
+ "royalblue": "#4169e1",
288
+ "saddlebrown": "#8b4513",
289
+ "salmon": "#fa8072",
290
+ "sandybrown": "#f4a460",
291
+ "seagreen": "#2e8b57",
292
+ "seashell": "#fff5ee",
293
+ "sienna": "#a0522d",
294
+ "silver": "#c0c0c0",
295
+ "skyblue": "#87ceeb",
296
+ "slateblue": "#6a5acd",
297
+ "slategray": "#708090",
298
+ "slategrey": "#708090",
299
+ "snow": "#fffafa",
300
+ "springgreen": "#00ff7f",
301
+ "steelblue": "#4682b4",
302
+ "tan": "#d2b48c",
303
+ "teal": "#008080",
304
+ "thistle": "#d8bfd8",
305
+ "tomato": "#ff6347",
306
+ "turquoise": "#40e0d0",
307
+ "violet": "#ee82ee",
308
+ "wheat": "#f5deb3",
309
+ "white": "#ffffff",
310
+ "whitesmoke": "#f5f5f5",
311
+ "yellow": "#ffff00",
312
+ "yellowgreen": "#9acd32",
313
+ }
env/Lib/site-packages/PIL/ImageDraw.py ADDED
@@ -0,0 +1,1062 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #
2
+ # The Python Imaging Library
3
+ # $Id$
4
+ #
5
+ # drawing interface operations
6
+ #
7
+ # History:
8
+ # 1996-04-13 fl Created (experimental)
9
+ # 1996-08-07 fl Filled polygons, ellipses.
10
+ # 1996-08-13 fl Added text support
11
+ # 1998-06-28 fl Handle I and F images
12
+ # 1998-12-29 fl Added arc; use arc primitive to draw ellipses
13
+ # 1999-01-10 fl Added shape stuff (experimental)
14
+ # 1999-02-06 fl Added bitmap support
15
+ # 1999-02-11 fl Changed all primitives to take options
16
+ # 1999-02-20 fl Fixed backwards compatibility
17
+ # 2000-10-12 fl Copy on write, when necessary
18
+ # 2001-02-18 fl Use default ink for bitmap/text also in fill mode
19
+ # 2002-10-24 fl Added support for CSS-style color strings
20
+ # 2002-12-10 fl Added experimental support for RGBA-on-RGB drawing
21
+ # 2002-12-11 fl Refactored low-level drawing API (work in progress)
22
+ # 2004-08-26 fl Made Draw() a factory function, added getdraw() support
23
+ # 2004-09-04 fl Added width support to line primitive
24
+ # 2004-09-10 fl Added font mode handling
25
+ # 2006-06-19 fl Added font bearing support (getmask2)
26
+ #
27
+ # Copyright (c) 1997-2006 by Secret Labs AB
28
+ # Copyright (c) 1996-2006 by Fredrik Lundh
29
+ #
30
+ # See the README file for information on usage and redistribution.
31
+ #
32
+
33
+ import math
34
+ import numbers
35
+
36
+ from . import Image, ImageColor
37
+
38
+ """
39
+ A simple 2D drawing interface for PIL images.
40
+ <p>
41
+ Application code should use the <b>Draw</b> factory, instead of
42
+ directly.
43
+ """
44
+
45
+
46
+ class ImageDraw:
47
+ font = None
48
+
49
+ def __init__(self, im, mode=None):
50
+ """
51
+ Create a drawing instance.
52
+
53
+ :param im: The image to draw in.
54
+ :param mode: Optional mode to use for color values. For RGB
55
+ images, this argument can be RGB or RGBA (to blend the
56
+ drawing into the image). For all other modes, this argument
57
+ must be the same as the image mode. If omitted, the mode
58
+ defaults to the mode of the image.
59
+ """
60
+ im.load()
61
+ if im.readonly:
62
+ im._copy() # make it writeable
63
+ blend = 0
64
+ if mode is None:
65
+ mode = im.mode
66
+ if mode != im.mode:
67
+ if mode == "RGBA" and im.mode == "RGB":
68
+ blend = 1
69
+ else:
70
+ msg = "mode mismatch"
71
+ raise ValueError(msg)
72
+ if mode == "P":
73
+ self.palette = im.palette
74
+ else:
75
+ self.palette = None
76
+ self._image = im
77
+ self.im = im.im
78
+ self.draw = Image.core.draw(self.im, blend)
79
+ self.mode = mode
80
+ if mode in ("I", "F"):
81
+ self.ink = self.draw.draw_ink(1)
82
+ else:
83
+ self.ink = self.draw.draw_ink(-1)
84
+ if mode in ("1", "P", "I", "F"):
85
+ # FIXME: fix Fill2 to properly support matte for I+F images
86
+ self.fontmode = "1"
87
+ else:
88
+ self.fontmode = "L" # aliasing is okay for other modes
89
+ self.fill = False
90
+
91
+ def getfont(self):
92
+ """
93
+ Get the current default font.
94
+
95
+ To set the default font for this ImageDraw instance::
96
+
97
+ from PIL import ImageDraw, ImageFont
98
+ draw.font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
99
+
100
+ To set the default font for all future ImageDraw instances::
101
+
102
+ from PIL import ImageDraw, ImageFont
103
+ ImageDraw.ImageDraw.font = ImageFont.truetype("Tests/fonts/FreeMono.ttf")
104
+
105
+ If the current default font is ``None``,
106
+ it is initialized with ``ImageFont.load_default()``.
107
+
108
+ :returns: An image font."""
109
+ if not self.font:
110
+ # FIXME: should add a font repository
111
+ from . import ImageFont
112
+
113
+ self.font = ImageFont.load_default()
114
+ return self.font
115
+
116
+ def _getfont(self, font_size):
117
+ if font_size is not None:
118
+ from . import ImageFont
119
+
120
+ font = ImageFont.load_default(font_size)
121
+ else:
122
+ font = self.getfont()
123
+ return font
124
+
125
+ def _getink(self, ink, fill=None):
126
+ if ink is None and fill is None:
127
+ if self.fill:
128
+ fill = self.ink
129
+ else:
130
+ ink = self.ink
131
+ else:
132
+ if ink is not None:
133
+ if isinstance(ink, str):
134
+ ink = ImageColor.getcolor(ink, self.mode)
135
+ if self.palette and not isinstance(ink, numbers.Number):
136
+ ink = self.palette.getcolor(ink, self._image)
137
+ ink = self.draw.draw_ink(ink)
138
+ if fill is not None:
139
+ if isinstance(fill, str):
140
+ fill = ImageColor.getcolor(fill, self.mode)
141
+ if self.palette and not isinstance(fill, numbers.Number):
142
+ fill = self.palette.getcolor(fill, self._image)
143
+ fill = self.draw.draw_ink(fill)
144
+ return ink, fill
145
+
146
+ def arc(self, xy, start, end, fill=None, width=1):
147
+ """Draw an arc."""
148
+ ink, fill = self._getink(fill)
149
+ if ink is not None:
150
+ self.draw.draw_arc(xy, start, end, ink, width)
151
+
152
+ def bitmap(self, xy, bitmap, fill=None):
153
+ """Draw a bitmap."""
154
+ bitmap.load()
155
+ ink, fill = self._getink(fill)
156
+ if ink is None:
157
+ ink = fill
158
+ if ink is not None:
159
+ self.draw.draw_bitmap(xy, bitmap.im, ink)
160
+
161
+ def chord(self, xy, start, end, fill=None, outline=None, width=1):
162
+ """Draw a chord."""
163
+ ink, fill = self._getink(outline, fill)
164
+ if fill is not None:
165
+ self.draw.draw_chord(xy, start, end, fill, 1)
166
+ if ink is not None and ink != fill and width != 0:
167
+ self.draw.draw_chord(xy, start, end, ink, 0, width)
168
+
169
+ def ellipse(self, xy, fill=None, outline=None, width=1):
170
+ """Draw an ellipse."""
171
+ ink, fill = self._getink(outline, fill)
172
+ if fill is not None:
173
+ self.draw.draw_ellipse(xy, fill, 1)
174
+ if ink is not None and ink != fill and width != 0:
175
+ self.draw.draw_ellipse(xy, ink, 0, width)
176
+
177
+ def line(self, xy, fill=None, width=0, joint=None):
178
+ """Draw a line, or a connected sequence of line segments."""
179
+ ink = self._getink(fill)[0]
180
+ if ink is not None:
181
+ self.draw.draw_lines(xy, ink, width)
182
+ if joint == "curve" and width > 4:
183
+ if not isinstance(xy[0], (list, tuple)):
184
+ xy = [tuple(xy[i : i + 2]) for i in range(0, len(xy), 2)]
185
+ for i in range(1, len(xy) - 1):
186
+ point = xy[i]
187
+ angles = [
188
+ math.degrees(math.atan2(end[0] - start[0], start[1] - end[1]))
189
+ % 360
190
+ for start, end in ((xy[i - 1], point), (point, xy[i + 1]))
191
+ ]
192
+ if angles[0] == angles[1]:
193
+ # This is a straight line, so no joint is required
194
+ continue
195
+
196
+ def coord_at_angle(coord, angle):
197
+ x, y = coord
198
+ angle -= 90
199
+ distance = width / 2 - 1
200
+ return tuple(
201
+ p + (math.floor(p_d) if p_d > 0 else math.ceil(p_d))
202
+ for p, p_d in (
203
+ (x, distance * math.cos(math.radians(angle))),
204
+ (y, distance * math.sin(math.radians(angle))),
205
+ )
206
+ )
207
+
208
+ flipped = (
209
+ angles[1] > angles[0] and angles[1] - 180 > angles[0]
210
+ ) or (angles[1] < angles[0] and angles[1] + 180 > angles[0])
211
+ coords = [
212
+ (point[0] - width / 2 + 1, point[1] - width / 2 + 1),
213
+ (point[0] + width / 2 - 1, point[1] + width / 2 - 1),
214
+ ]
215
+ if flipped:
216
+ start, end = (angles[1] + 90, angles[0] + 90)
217
+ else:
218
+ start, end = (angles[0] - 90, angles[1] - 90)
219
+ self.pieslice(coords, start - 90, end - 90, fill)
220
+
221
+ if width > 8:
222
+ # Cover potential gaps between the line and the joint
223
+ if flipped:
224
+ gap_coords = [
225
+ coord_at_angle(point, angles[0] + 90),
226
+ point,
227
+ coord_at_angle(point, angles[1] + 90),
228
+ ]
229
+ else:
230
+ gap_coords = [
231
+ coord_at_angle(point, angles[0] - 90),
232
+ point,
233
+ coord_at_angle(point, angles[1] - 90),
234
+ ]
235
+ self.line(gap_coords, fill, width=3)
236
+
237
+ def shape(self, shape, fill=None, outline=None):
238
+ """(Experimental) Draw a shape."""
239
+ shape.close()
240
+ ink, fill = self._getink(outline, fill)
241
+ if fill is not None:
242
+ self.draw.draw_outline(shape, fill, 1)
243
+ if ink is not None and ink != fill:
244
+ self.draw.draw_outline(shape, ink, 0)
245
+
246
+ def pieslice(self, xy, start, end, fill=None, outline=None, width=1):
247
+ """Draw a pieslice."""
248
+ ink, fill = self._getink(outline, fill)
249
+ if fill is not None:
250
+ self.draw.draw_pieslice(xy, start, end, fill, 1)
251
+ if ink is not None and ink != fill and width != 0:
252
+ self.draw.draw_pieslice(xy, start, end, ink, 0, width)
253
+
254
+ def point(self, xy, fill=None):
255
+ """Draw one or more individual pixels."""
256
+ ink, fill = self._getink(fill)
257
+ if ink is not None:
258
+ self.draw.draw_points(xy, ink)
259
+
260
+ def polygon(self, xy, fill=None, outline=None, width=1):
261
+ """Draw a polygon."""
262
+ ink, fill = self._getink(outline, fill)
263
+ if fill is not None:
264
+ self.draw.draw_polygon(xy, fill, 1)
265
+ if ink is not None and ink != fill and width != 0:
266
+ if width == 1:
267
+ self.draw.draw_polygon(xy, ink, 0, width)
268
+ else:
269
+ # To avoid expanding the polygon outwards,
270
+ # use the fill as a mask
271
+ mask = Image.new("1", self.im.size)
272
+ mask_ink = self._getink(1)[0]
273
+
274
+ fill_im = mask.copy()
275
+ draw = Draw(fill_im)
276
+ draw.draw.draw_polygon(xy, mask_ink, 1)
277
+
278
+ ink_im = mask.copy()
279
+ draw = Draw(ink_im)
280
+ width = width * 2 - 1
281
+ draw.draw.draw_polygon(xy, mask_ink, 0, width)
282
+
283
+ mask.paste(ink_im, mask=fill_im)
284
+
285
+ im = Image.new(self.mode, self.im.size)
286
+ draw = Draw(im)
287
+ draw.draw.draw_polygon(xy, ink, 0, width)
288
+ self.im.paste(im.im, (0, 0) + im.size, mask.im)
289
+
290
+ def regular_polygon(
291
+ self, bounding_circle, n_sides, rotation=0, fill=None, outline=None, width=1
292
+ ):
293
+ """Draw a regular polygon."""
294
+ xy = _compute_regular_polygon_vertices(bounding_circle, n_sides, rotation)
295
+ self.polygon(xy, fill, outline, width)
296
+
297
+ def rectangle(self, xy, fill=None, outline=None, width=1):
298
+ """Draw a rectangle."""
299
+ ink, fill = self._getink(outline, fill)
300
+ if fill is not None:
301
+ self.draw.draw_rectangle(xy, fill, 1)
302
+ if ink is not None and ink != fill and width != 0:
303
+ self.draw.draw_rectangle(xy, ink, 0, width)
304
+
305
+ def rounded_rectangle(
306
+ self, xy, radius=0, fill=None, outline=None, width=1, *, corners=None
307
+ ):
308
+ """Draw a rounded rectangle."""
309
+ if isinstance(xy[0], (list, tuple)):
310
+ (x0, y0), (x1, y1) = xy
311
+ else:
312
+ x0, y0, x1, y1 = xy
313
+ if x1 < x0:
314
+ msg = "x1 must be greater than or equal to x0"
315
+ raise ValueError(msg)
316
+ if y1 < y0:
317
+ msg = "y1 must be greater than or equal to y0"
318
+ raise ValueError(msg)
319
+ if corners is None:
320
+ corners = (True, True, True, True)
321
+
322
+ d = radius * 2
323
+
324
+ full_x, full_y = False, False
325
+ if all(corners):
326
+ full_x = d >= x1 - x0 - 1
327
+ if full_x:
328
+ # The two left and two right corners are joined
329
+ d = x1 - x0
330
+ full_y = d >= y1 - y0 - 1
331
+ if full_y:
332
+ # The two top and two bottom corners are joined
333
+ d = y1 - y0
334
+ if full_x and full_y:
335
+ # If all corners are joined, that is a circle
336
+ return self.ellipse(xy, fill, outline, width)
337
+
338
+ if d == 0 or not any(corners):
339
+ # If the corners have no curve,
340
+ # or there are no corners,
341
+ # that is a rectangle
342
+ return self.rectangle(xy, fill, outline, width)
343
+
344
+ r = d // 2
345
+ ink, fill = self._getink(outline, fill)
346
+
347
+ def draw_corners(pieslice):
348
+ if full_x:
349
+ # Draw top and bottom halves
350
+ parts = (
351
+ ((x0, y0, x0 + d, y0 + d), 180, 360),
352
+ ((x0, y1 - d, x0 + d, y1), 0, 180),
353
+ )
354
+ elif full_y:
355
+ # Draw left and right halves
356
+ parts = (
357
+ ((x0, y0, x0 + d, y0 + d), 90, 270),
358
+ ((x1 - d, y0, x1, y0 + d), 270, 90),
359
+ )
360
+ else:
361
+ # Draw four separate corners
362
+ parts = []
363
+ for i, part in enumerate(
364
+ (
365
+ ((x0, y0, x0 + d, y0 + d), 180, 270),
366
+ ((x1 - d, y0, x1, y0 + d), 270, 360),
367
+ ((x1 - d, y1 - d, x1, y1), 0, 90),
368
+ ((x0, y1 - d, x0 + d, y1), 90, 180),
369
+ )
370
+ ):
371
+ if corners[i]:
372
+ parts.append(part)
373
+ for part in parts:
374
+ if pieslice:
375
+ self.draw.draw_pieslice(*(part + (fill, 1)))
376
+ else:
377
+ self.draw.draw_arc(*(part + (ink, width)))
378
+
379
+ if fill is not None:
380
+ draw_corners(True)
381
+
382
+ if full_x:
383
+ self.draw.draw_rectangle((x0, y0 + r + 1, x1, y1 - r - 1), fill, 1)
384
+ else:
385
+ self.draw.draw_rectangle((x0 + r + 1, y0, x1 - r - 1, y1), fill, 1)
386
+ if not full_x and not full_y:
387
+ left = [x0, y0, x0 + r, y1]
388
+ if corners[0]:
389
+ left[1] += r + 1
390
+ if corners[3]:
391
+ left[3] -= r + 1
392
+ self.draw.draw_rectangle(left, fill, 1)
393
+
394
+ right = [x1 - r, y0, x1, y1]
395
+ if corners[1]:
396
+ right[1] += r + 1
397
+ if corners[2]:
398
+ right[3] -= r + 1
399
+ self.draw.draw_rectangle(right, fill, 1)
400
+ if ink is not None and ink != fill and width != 0:
401
+ draw_corners(False)
402
+
403
+ if not full_x:
404
+ top = [x0, y0, x1, y0 + width - 1]
405
+ if corners[0]:
406
+ top[0] += r + 1
407
+ if corners[1]:
408
+ top[2] -= r + 1
409
+ self.draw.draw_rectangle(top, ink, 1)
410
+
411
+ bottom = [x0, y1 - width + 1, x1, y1]
412
+ if corners[3]:
413
+ bottom[0] += r + 1
414
+ if corners[2]:
415
+ bottom[2] -= r + 1
416
+ self.draw.draw_rectangle(bottom, ink, 1)
417
+ if not full_y:
418
+ left = [x0, y0, x0 + width - 1, y1]
419
+ if corners[0]:
420
+ left[1] += r + 1
421
+ if corners[3]:
422
+ left[3] -= r + 1
423
+ self.draw.draw_rectangle(left, ink, 1)
424
+
425
+ right = [x1 - width + 1, y0, x1, y1]
426
+ if corners[1]:
427
+ right[1] += r + 1
428
+ if corners[2]:
429
+ right[3] -= r + 1
430
+ self.draw.draw_rectangle(right, ink, 1)
431
+
432
+ def _multiline_check(self, text):
433
+ split_character = "\n" if isinstance(text, str) else b"\n"
434
+
435
+ return split_character in text
436
+
437
+ def _multiline_split(self, text):
438
+ split_character = "\n" if isinstance(text, str) else b"\n"
439
+
440
+ return text.split(split_character)
441
+
442
+ def _multiline_spacing(self, font, spacing, stroke_width):
443
+ return (
444
+ self.textbbox((0, 0), "A", font, stroke_width=stroke_width)[3]
445
+ + stroke_width
446
+ + spacing
447
+ )
448
+
449
+ def text(
450
+ self,
451
+ xy,
452
+ text,
453
+ fill=None,
454
+ font=None,
455
+ anchor=None,
456
+ spacing=4,
457
+ align="left",
458
+ direction=None,
459
+ features=None,
460
+ language=None,
461
+ stroke_width=0,
462
+ stroke_fill=None,
463
+ embedded_color=False,
464
+ *args,
465
+ **kwargs,
466
+ ):
467
+ """Draw text."""
468
+ if embedded_color and self.mode not in ("RGB", "RGBA"):
469
+ msg = "Embedded color supported only in RGB and RGBA modes"
470
+ raise ValueError(msg)
471
+
472
+ if font is None:
473
+ font = self._getfont(kwargs.get("font_size"))
474
+
475
+ if self._multiline_check(text):
476
+ return self.multiline_text(
477
+ xy,
478
+ text,
479
+ fill,
480
+ font,
481
+ anchor,
482
+ spacing,
483
+ align,
484
+ direction,
485
+ features,
486
+ language,
487
+ stroke_width,
488
+ stroke_fill,
489
+ embedded_color,
490
+ )
491
+
492
+ def getink(fill):
493
+ ink, fill = self._getink(fill)
494
+ if ink is None:
495
+ return fill
496
+ return ink
497
+
498
+ def draw_text(ink, stroke_width=0, stroke_offset=None):
499
+ mode = self.fontmode
500
+ if stroke_width == 0 and embedded_color:
501
+ mode = "RGBA"
502
+ coord = []
503
+ start = []
504
+ for i in range(2):
505
+ coord.append(int(xy[i]))
506
+ start.append(math.modf(xy[i])[0])
507
+ try:
508
+ mask, offset = font.getmask2(
509
+ text,
510
+ mode,
511
+ direction=direction,
512
+ features=features,
513
+ language=language,
514
+ stroke_width=stroke_width,
515
+ anchor=anchor,
516
+ ink=ink,
517
+ start=start,
518
+ *args,
519
+ **kwargs,
520
+ )
521
+ coord = coord[0] + offset[0], coord[1] + offset[1]
522
+ except AttributeError:
523
+ try:
524
+ mask = font.getmask(
525
+ text,
526
+ mode,
527
+ direction,
528
+ features,
529
+ language,
530
+ stroke_width,
531
+ anchor,
532
+ ink,
533
+ start=start,
534
+ *args,
535
+ **kwargs,
536
+ )
537
+ except TypeError:
538
+ mask = font.getmask(text)
539
+ if stroke_offset:
540
+ coord = coord[0] + stroke_offset[0], coord[1] + stroke_offset[1]
541
+ if mode == "RGBA":
542
+ # font.getmask2(mode="RGBA") returns color in RGB bands and mask in A
543
+ # extract mask and set text alpha
544
+ color, mask = mask, mask.getband(3)
545
+ color.fillband(3, (ink >> 24) & 0xFF)
546
+ x, y = coord
547
+ self.im.paste(color, (x, y, x + mask.size[0], y + mask.size[1]), mask)
548
+ else:
549
+ self.draw.draw_bitmap(coord, mask, ink)
550
+
551
+ ink = getink(fill)
552
+ if ink is not None:
553
+ stroke_ink = None
554
+ if stroke_width:
555
+ stroke_ink = getink(stroke_fill) if stroke_fill is not None else ink
556
+
557
+ if stroke_ink is not None:
558
+ # Draw stroked text
559
+ draw_text(stroke_ink, stroke_width)
560
+
561
+ # Draw normal text
562
+ draw_text(ink, 0)
563
+ else:
564
+ # Only draw normal text
565
+ draw_text(ink)
566
+
567
+ def multiline_text(
568
+ self,
569
+ xy,
570
+ text,
571
+ fill=None,
572
+ font=None,
573
+ anchor=None,
574
+ spacing=4,
575
+ align="left",
576
+ direction=None,
577
+ features=None,
578
+ language=None,
579
+ stroke_width=0,
580
+ stroke_fill=None,
581
+ embedded_color=False,
582
+ *,
583
+ font_size=None,
584
+ ):
585
+ if direction == "ttb":
586
+ msg = "ttb direction is unsupported for multiline text"
587
+ raise ValueError(msg)
588
+
589
+ if anchor is None:
590
+ anchor = "la"
591
+ elif len(anchor) != 2:
592
+ msg = "anchor must be a 2 character string"
593
+ raise ValueError(msg)
594
+ elif anchor[1] in "tb":
595
+ msg = "anchor not supported for multiline text"
596
+ raise ValueError(msg)
597
+
598
+ if font is None:
599
+ font = self._getfont(font_size)
600
+
601
+ widths = []
602
+ max_width = 0
603
+ lines = self._multiline_split(text)
604
+ line_spacing = self._multiline_spacing(font, spacing, stroke_width)
605
+ for line in lines:
606
+ line_width = self.textlength(
607
+ line, font, direction=direction, features=features, language=language
608
+ )
609
+ widths.append(line_width)
610
+ max_width = max(max_width, line_width)
611
+
612
+ top = xy[1]
613
+ if anchor[1] == "m":
614
+ top -= (len(lines) - 1) * line_spacing / 2.0
615
+ elif anchor[1] == "d":
616
+ top -= (len(lines) - 1) * line_spacing
617
+
618
+ for idx, line in enumerate(lines):
619
+ left = xy[0]
620
+ width_difference = max_width - widths[idx]
621
+
622
+ # first align left by anchor
623
+ if anchor[0] == "m":
624
+ left -= width_difference / 2.0
625
+ elif anchor[0] == "r":
626
+ left -= width_difference
627
+
628
+ # then align by align parameter
629
+ if align == "left":
630
+ pass
631
+ elif align == "center":
632
+ left += width_difference / 2.0
633
+ elif align == "right":
634
+ left += width_difference
635
+ else:
636
+ msg = 'align must be "left", "center" or "right"'
637
+ raise ValueError(msg)
638
+
639
+ self.text(
640
+ (left, top),
641
+ line,
642
+ fill,
643
+ font,
644
+ anchor,
645
+ direction=direction,
646
+ features=features,
647
+ language=language,
648
+ stroke_width=stroke_width,
649
+ stroke_fill=stroke_fill,
650
+ embedded_color=embedded_color,
651
+ )
652
+ top += line_spacing
653
+
654
+ def textlength(
655
+ self,
656
+ text,
657
+ font=None,
658
+ direction=None,
659
+ features=None,
660
+ language=None,
661
+ embedded_color=False,
662
+ *,
663
+ font_size=None,
664
+ ):
665
+ """Get the length of a given string, in pixels with 1/64 precision."""
666
+ if self._multiline_check(text):
667
+ msg = "can't measure length of multiline text"
668
+ raise ValueError(msg)
669
+ if embedded_color and self.mode not in ("RGB", "RGBA"):
670
+ msg = "Embedded color supported only in RGB and RGBA modes"
671
+ raise ValueError(msg)
672
+
673
+ if font is None:
674
+ font = self._getfont(font_size)
675
+ mode = "RGBA" if embedded_color else self.fontmode
676
+ return font.getlength(text, mode, direction, features, language)
677
+
678
+ def textbbox(
679
+ self,
680
+ xy,
681
+ text,
682
+ font=None,
683
+ anchor=None,
684
+ spacing=4,
685
+ align="left",
686
+ direction=None,
687
+ features=None,
688
+ language=None,
689
+ stroke_width=0,
690
+ embedded_color=False,
691
+ *,
692
+ font_size=None,
693
+ ):
694
+ """Get the bounding box of a given string, in pixels."""
695
+ if embedded_color and self.mode not in ("RGB", "RGBA"):
696
+ msg = "Embedded color supported only in RGB and RGBA modes"
697
+ raise ValueError(msg)
698
+
699
+ if font is None:
700
+ font = self._getfont(font_size)
701
+
702
+ if self._multiline_check(text):
703
+ return self.multiline_textbbox(
704
+ xy,
705
+ text,
706
+ font,
707
+ anchor,
708
+ spacing,
709
+ align,
710
+ direction,
711
+ features,
712
+ language,
713
+ stroke_width,
714
+ embedded_color,
715
+ )
716
+
717
+ mode = "RGBA" if embedded_color else self.fontmode
718
+ bbox = font.getbbox(
719
+ text, mode, direction, features, language, stroke_width, anchor
720
+ )
721
+ return bbox[0] + xy[0], bbox[1] + xy[1], bbox[2] + xy[0], bbox[3] + xy[1]
722
+
723
+ def multiline_textbbox(
724
+ self,
725
+ xy,
726
+ text,
727
+ font=None,
728
+ anchor=None,
729
+ spacing=4,
730
+ align="left",
731
+ direction=None,
732
+ features=None,
733
+ language=None,
734
+ stroke_width=0,
735
+ embedded_color=False,
736
+ *,
737
+ font_size=None,
738
+ ):
739
+ if direction == "ttb":
740
+ msg = "ttb direction is unsupported for multiline text"
741
+ raise ValueError(msg)
742
+
743
+ if anchor is None:
744
+ anchor = "la"
745
+ elif len(anchor) != 2:
746
+ msg = "anchor must be a 2 character string"
747
+ raise ValueError(msg)
748
+ elif anchor[1] in "tb":
749
+ msg = "anchor not supported for multiline text"
750
+ raise ValueError(msg)
751
+
752
+ if font is None:
753
+ font = self._getfont(font_size)
754
+
755
+ widths = []
756
+ max_width = 0
757
+ lines = self._multiline_split(text)
758
+ line_spacing = self._multiline_spacing(font, spacing, stroke_width)
759
+ for line in lines:
760
+ line_width = self.textlength(
761
+ line,
762
+ font,
763
+ direction=direction,
764
+ features=features,
765
+ language=language,
766
+ embedded_color=embedded_color,
767
+ )
768
+ widths.append(line_width)
769
+ max_width = max(max_width, line_width)
770
+
771
+ top = xy[1]
772
+ if anchor[1] == "m":
773
+ top -= (len(lines) - 1) * line_spacing / 2.0
774
+ elif anchor[1] == "d":
775
+ top -= (len(lines) - 1) * line_spacing
776
+
777
+ bbox = None
778
+
779
+ for idx, line in enumerate(lines):
780
+ left = xy[0]
781
+ width_difference = max_width - widths[idx]
782
+
783
+ # first align left by anchor
784
+ if anchor[0] == "m":
785
+ left -= width_difference / 2.0
786
+ elif anchor[0] == "r":
787
+ left -= width_difference
788
+
789
+ # then align by align parameter
790
+ if align == "left":
791
+ pass
792
+ elif align == "center":
793
+ left += width_difference / 2.0
794
+ elif align == "right":
795
+ left += width_difference
796
+ else:
797
+ msg = 'align must be "left", "center" or "right"'
798
+ raise ValueError(msg)
799
+
800
+ bbox_line = self.textbbox(
801
+ (left, top),
802
+ line,
803
+ font,
804
+ anchor,
805
+ direction=direction,
806
+ features=features,
807
+ language=language,
808
+ stroke_width=stroke_width,
809
+ embedded_color=embedded_color,
810
+ )
811
+ if bbox is None:
812
+ bbox = bbox_line
813
+ else:
814
+ bbox = (
815
+ min(bbox[0], bbox_line[0]),
816
+ min(bbox[1], bbox_line[1]),
817
+ max(bbox[2], bbox_line[2]),
818
+ max(bbox[3], bbox_line[3]),
819
+ )
820
+
821
+ top += line_spacing
822
+
823
+ if bbox is None:
824
+ return xy[0], xy[1], xy[0], xy[1]
825
+ return bbox
826
+
827
+
828
+ def Draw(im, mode=None):
829
+ """
830
+ A simple 2D drawing interface for PIL images.
831
+
832
+ :param im: The image to draw in.
833
+ :param mode: Optional mode to use for color values. For RGB
834
+ images, this argument can be RGB or RGBA (to blend the
835
+ drawing into the image). For all other modes, this argument
836
+ must be the same as the image mode. If omitted, the mode
837
+ defaults to the mode of the image.
838
+ """
839
+ try:
840
+ return im.getdraw(mode)
841
+ except AttributeError:
842
+ return ImageDraw(im, mode)
843
+
844
+
845
+ # experimental access to the outline API
846
+ try:
847
+ Outline = Image.core.outline
848
+ except AttributeError:
849
+ Outline = None
850
+
851
+
852
+ def getdraw(im=None, hints=None):
853
+ """
854
+ (Experimental) A more advanced 2D drawing interface for PIL images,
855
+ based on the WCK interface.
856
+
857
+ :param im: The image to draw in.
858
+ :param hints: An optional list of hints.
859
+ :returns: A (drawing context, drawing resource factory) tuple.
860
+ """
861
+ # FIXME: this needs more work!
862
+ # FIXME: come up with a better 'hints' scheme.
863
+ handler = None
864
+ if not hints or "nicest" in hints:
865
+ try:
866
+ from . import _imagingagg as handler
867
+ except ImportError:
868
+ pass
869
+ if handler is None:
870
+ from . import ImageDraw2 as handler
871
+ if im:
872
+ im = handler.Draw(im)
873
+ return im, handler
874
+
875
+
876
+ def floodfill(image, xy, value, border=None, thresh=0):
877
+ """
878
+ (experimental) Fills a bounded region with a given color.
879
+
880
+ :param image: Target image.
881
+ :param xy: Seed position (a 2-item coordinate tuple). See
882
+ :ref:`coordinate-system`.
883
+ :param value: Fill color.
884
+ :param border: Optional border value. If given, the region consists of
885
+ pixels with a color different from the border color. If not given,
886
+ the region consists of pixels having the same color as the seed
887
+ pixel.
888
+ :param thresh: Optional threshold value which specifies a maximum
889
+ tolerable difference of a pixel value from the 'background' in
890
+ order for it to be replaced. Useful for filling regions of
891
+ non-homogeneous, but similar, colors.
892
+ """
893
+ # based on an implementation by Eric S. Raymond
894
+ # amended by yo1995 @20180806
895
+ pixel = image.load()
896
+ x, y = xy
897
+ try:
898
+ background = pixel[x, y]
899
+ if _color_diff(value, background) <= thresh:
900
+ return # seed point already has fill color
901
+ pixel[x, y] = value
902
+ except (ValueError, IndexError):
903
+ return # seed point outside image
904
+ edge = {(x, y)}
905
+ # use a set to keep record of current and previous edge pixels
906
+ # to reduce memory consumption
907
+ full_edge = set()
908
+ while edge:
909
+ new_edge = set()
910
+ for x, y in edge: # 4 adjacent method
911
+ for s, t in ((x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)):
912
+ # If already processed, or if a coordinate is negative, skip
913
+ if (s, t) in full_edge or s < 0 or t < 0:
914
+ continue
915
+ try:
916
+ p = pixel[s, t]
917
+ except (ValueError, IndexError):
918
+ pass
919
+ else:
920
+ full_edge.add((s, t))
921
+ if border is None:
922
+ fill = _color_diff(p, background) <= thresh
923
+ else:
924
+ fill = p != value and p != border
925
+ if fill:
926
+ pixel[s, t] = value
927
+ new_edge.add((s, t))
928
+ full_edge = edge # discard pixels processed
929
+ edge = new_edge
930
+
931
+
932
+ def _compute_regular_polygon_vertices(bounding_circle, n_sides, rotation):
933
+ """
934
+ Generate a list of vertices for a 2D regular polygon.
935
+
936
+ :param bounding_circle: The bounding circle is a tuple defined
937
+ by a point and radius. The polygon is inscribed in this circle.
938
+ (e.g. ``bounding_circle=(x, y, r)`` or ``((x, y), r)``)
939
+ :param n_sides: Number of sides
940
+ (e.g. ``n_sides=3`` for a triangle, ``6`` for a hexagon)
941
+ :param rotation: Apply an arbitrary rotation to the polygon
942
+ (e.g. ``rotation=90``, applies a 90 degree rotation)
943
+ :return: List of regular polygon vertices
944
+ (e.g. ``[(25, 50), (50, 50), (50, 25), (25, 25)]``)
945
+
946
+ How are the vertices computed?
947
+ 1. Compute the following variables
948
+ - theta: Angle between the apothem & the nearest polygon vertex
949
+ - side_length: Length of each polygon edge
950
+ - centroid: Center of bounding circle (1st, 2nd elements of bounding_circle)
951
+ - polygon_radius: Polygon radius (last element of bounding_circle)
952
+ - angles: Location of each polygon vertex in polar grid
953
+ (e.g. A square with 0 degree rotation => [225.0, 315.0, 45.0, 135.0])
954
+
955
+ 2. For each angle in angles, get the polygon vertex at that angle
956
+ The vertex is computed using the equation below.
957
+ X= xcos(φ) + ysin(φ)
958
+ Y= −xsin(φ) + ycos(φ)
959
+
960
+ Note:
961
+ φ = angle in degrees
962
+ x = 0
963
+ y = polygon_radius
964
+
965
+ The formula above assumes rotation around the origin.
966
+ In our case, we are rotating around the centroid.
967
+ To account for this, we use the formula below
968
+ X = xcos(φ) + ysin(φ) + centroid_x
969
+ Y = −xsin(φ) + ycos(φ) + centroid_y
970
+ """
971
+ # 1. Error Handling
972
+ # 1.1 Check `n_sides` has an appropriate value
973
+ if not isinstance(n_sides, int):
974
+ msg = "n_sides should be an int"
975
+ raise TypeError(msg)
976
+ if n_sides < 3:
977
+ msg = "n_sides should be an int > 2"
978
+ raise ValueError(msg)
979
+
980
+ # 1.2 Check `bounding_circle` has an appropriate value
981
+ if not isinstance(bounding_circle, (list, tuple)):
982
+ msg = "bounding_circle should be a tuple"
983
+ raise TypeError(msg)
984
+
985
+ if len(bounding_circle) == 3:
986
+ *centroid, polygon_radius = bounding_circle
987
+ elif len(bounding_circle) == 2:
988
+ centroid, polygon_radius = bounding_circle
989
+ else:
990
+ msg = (
991
+ "bounding_circle should contain 2D coordinates "
992
+ "and a radius (e.g. (x, y, r) or ((x, y), r) )"
993
+ )
994
+ raise ValueError(msg)
995
+
996
+ if not all(isinstance(i, (int, float)) for i in (*centroid, polygon_radius)):
997
+ msg = "bounding_circle should only contain numeric data"
998
+ raise ValueError(msg)
999
+
1000
+ if not len(centroid) == 2:
1001
+ msg = "bounding_circle centre should contain 2D coordinates (e.g. (x, y))"
1002
+ raise ValueError(msg)
1003
+
1004
+ if polygon_radius <= 0:
1005
+ msg = "bounding_circle radius should be > 0"
1006
+ raise ValueError(msg)
1007
+
1008
+ # 1.3 Check `rotation` has an appropriate value
1009
+ if not isinstance(rotation, (int, float)):
1010
+ msg = "rotation should be an int or float"
1011
+ raise ValueError(msg)
1012
+
1013
+ # 2. Define Helper Functions
1014
+ def _apply_rotation(point, degrees, centroid):
1015
+ return (
1016
+ round(
1017
+ point[0] * math.cos(math.radians(360 - degrees))
1018
+ - point[1] * math.sin(math.radians(360 - degrees))
1019
+ + centroid[0],
1020
+ 2,
1021
+ ),
1022
+ round(
1023
+ point[1] * math.cos(math.radians(360 - degrees))
1024
+ + point[0] * math.sin(math.radians(360 - degrees))
1025
+ + centroid[1],
1026
+ 2,
1027
+ ),
1028
+ )
1029
+
1030
+ def _compute_polygon_vertex(centroid, polygon_radius, angle):
1031
+ start_point = [polygon_radius, 0]
1032
+ return _apply_rotation(start_point, angle, centroid)
1033
+
1034
+ def _get_angles(n_sides, rotation):
1035
+ angles = []
1036
+ degrees = 360 / n_sides
1037
+ # Start with the bottom left polygon vertex
1038
+ current_angle = (270 - 0.5 * degrees) + rotation
1039
+ for _ in range(0, n_sides):
1040
+ angles.append(current_angle)
1041
+ current_angle += degrees
1042
+ if current_angle > 360:
1043
+ current_angle -= 360
1044
+ return angles
1045
+
1046
+ # 3. Variable Declarations
1047
+ angles = _get_angles(n_sides, rotation)
1048
+
1049
+ # 4. Compute Vertices
1050
+ return [
1051
+ _compute_polygon_vertex(centroid, polygon_radius, angle) for angle in angles
1052
+ ]
1053
+
1054
+
1055
+ def _color_diff(color1, color2):
1056
+ """
1057
+ Uses 1-norm distance to calculate difference between two values.
1058
+ """
1059
+ if isinstance(color2, tuple):
1060
+ return sum(abs(color1[i] - color2[i]) for i in range(0, len(color2)))
1061
+ else:
1062
+ return abs(color1 - color2)