flake8

.vscode/extensions.json

@@ -0,0 +1,5 @@
+{
+  "recommendations": [
+    "ms-python.flake8"
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,16 @@
+{
+  "cSpell.words": [
+    "astype",
+    "dtype",
+    "fromarray",
+    "Gradio",
+    "inbrowser",
+    "ndarray"
+  ],
+  "python.analysis.typeCheckingMode": "basic",
+  "flake8.args": [
+    "--ignore=E265,W291",
+    "--max-complexity=10",
+    "--max-line-length=127"
+  ]
+}

app.py

@@ -4,11 +4,12 @@
 """
 from argparse import ArgumentParser, BooleanOptionalAction
 
-import src.utils as utils
-from src.reporter import get_current_reporter
-        
+from src.utils import get_package_version
+from src.myapp import run_app
+
 PROGRAM_NAME = 'SaliencyMapDemo'
-__version__ = utils.get_package_version()
+__version__ = get_package_version()
+
 
 def main():
     """
@@ -16,22 +17,20 @@ def main():
         1, コマンドライン引数の解析を行います
         2, アプリを起動します。
     """
-    log = get_current_reporter()
-    log.info("#アプリ起動中")
-    watch = utils.Stopwatch.startNew()
-    
-    from src.myapp import runApp
-
     parser = ArgumentParser(prog=PROGRAM_NAME, description="SaliencyMapDemo")
-    parser.add_argument('--server_port', type=int, default=7860, help="Gradio server port")
-    parser.add_argument('--max_file_size', type=int, default=20 * 1024 * 1024, help="Gradio max file size")
-    parser.add_argument('--inbrowser',  action=BooleanOptionalAction, default=True, help="Gradio inbrowser")
-    parser.add_argument('--share', action=BooleanOptionalAction, default=False, help="Gradio share")
+    parser.add_argument('--inbrowser',
+                        action=BooleanOptionalAction, default=True, help="Gradio inbrowser")
+    parser.add_argument('--share',
+                        action=BooleanOptionalAction, default=False, help="Gradio share")
+    parser.add_argument('--server_port',
+                        type=int, default=7860, help="Gradio server port")
+    parser.add_argument('--max_file_size',
+                        type=str, default="20MB", help="Gradio max file size")
     parser.add_argument('--version', action='version', version=f'%(prog)s {__version__}')
-    
+
     args = parser.parse_args()
-    
-    runApp(args, watch)
+    run_app(args)
+
 
 if __name__ == "__main__":
     main()

src/myapp.py

@@ -1,40 +1,54 @@
 # -*- coding: utf-8 -*-
+"""myapp Widget"""
 from typing import Literal
 
 import argparse
-from datetime import datetime
+#from datetime import datetime
 import sys
 
 import gradio as gr
 import numpy as np
 
-import src.utils as utils
-from src.saliency import SaliencyMap, convertColorMap
+from src.utils import Stopwatch, get_package_version
+from src.saliency import SaliencyMap, convert_colormap
 from src.reporter import get_current_reporter
 
 PROGRAM_NAME = 'SaliencyMapDemo'
-__version__ = utils.get_package_version()
+__version__ = get_package_version()
 log = get_current_reporter()
-    
-def jetTab_Selected(image: np.ndarray):
+log.info("#アプリ起動中")
+watch = Stopwatch.start_new()
+
+
+def jettab_selected(image: np.ndarray):
+    """
+    JETタブを選択時
+    """
     #print(f"{datetime.now()}#jet")
     saliency = SaliencyMap("SpectralResidual")
-    success, saliencyMap = saliency.computeSaliency(image)
-    retval = convertColorMap(image, saliencyMap, "jet")
+    success, saliency_map = saliency.compute(image)
+    if not success:
+        return image  # エラーが発生した場合は入力画像を返します。
+    retval = convert_colormap(image, saliency_map, "jet")
     #print(f"{datetime.now()}#jet")
-    
     return retval
-    
-def hotTab_Selected(image: np.ndarray):
+
+
+def hottab_selected(image: np.ndarray):
+    """
+    HOTタブを選択時
+    """
     #print(f"{datetime.now()}#hot")
     saliency = SaliencyMap("SpectralResidual")
-    success, saliencyMap = saliency.computeSaliency(image)
-    retval = convertColorMap(image, saliencyMap, "turbo")
+    success, saliency_map = saliency.compute(image)
+    if not success:
+        return image  # エラーが発生した場合は入力画像を返します。
+    retval = convert_colormap(image, saliency_map, "turbo")
     #print(f"{datetime.now()}#hot")
-    
     return retval
 
-def submit_Clicked(image: np.ndarray, algorithm: str):
+
+def submit_clicked(image: np.ndarray, algorithm: Literal["SpectralResidual", "FineGrained"]):
     """
     入力画像を元に顕著マップを計算します。
 
@@ -46,27 +60,26 @@ def submit_Clicked(image: np.ndarray, algorithm: str):
         np.ndarray: HOT画像
     """
     #log.info(f"#submit_Clicked")
-    watch = utils.Stopwatch.startNew()
-    
+    #watch = utils.Stopwatch.startNew()
+    #
     saliency = SaliencyMap(algorithm)
-    success, saliencyMap = saliency.computeSaliency(image)
-    #log.info(f"#SaliencyMap computeSaliency()")
+    success, saliency_map = saliency.compute(image)
+    # log.info(f"#SaliencyMap compute()")
 
     if not success:
-        return image, image # エラーが発生した場合は入力画像を返します。
-
-    #log.info(f"#jet")        
-    jet = convertColorMap(image, saliencyMap, "jet")
-    #jet = None
-    #log.info(f"#hot")
-    hot = convertColorMap(image, saliencyMap, "hot")
-    
+        return image, image  # エラーが発生した場合は入力画像を返します。
+
+    # log.info(f"#jet")
+    jet = convert_colormap(image, saliency_map, "jet")
+    # jet = None
+    # log.info(f"#hot")
+    hot = convert_colormap(image, saliency_map, "hot")
     saliency = None
     #log.info(f"#submit_Clicked End{watch.stop():.3f}")
-    
     return jet, hot
 
-def runApp(args: argparse.Namespace, watch: utils.Stopwatch) -> None:
+
+def run_app(args: argparse.Namespace) -> None:
     """
     アプリの画面を作成し、Gradioサービスを起動します。
 
@@ -76,59 +89,68 @@ def runApp(args: argparse.Namespace, watch: utils.Stopwatch) -> None:
     """
     # analytics_enabled=False
     # https://github.com/gradio-app/gradio/issues/4226
-    with gr.Blocks(analytics_enabled=False, \
-        title=f"{PROGRAM_NAME} {__version__}", \
+    with gr.Blocks(
+        analytics_enabled=False,
+        title=f"{PROGRAM_NAME} {__version__}",
         head="""
         <meta name="format-detection" content="telephone=no">
         <meta name="robots" content="noindex, nofollow, noarchive">
         <meta name="referrer" content="no-referrer" />
-        """) as demo:
-    	
-        gr.Markdown(
         """
-        # Saliency Map demo.
-        """)
+    ) as demo:
+
+        gr.Markdown("""
+            # Saliency Map demo.
+            """)
         with gr.Accordion("取り扱い説明書", open=False):
-            gr.Markdown(
-            """
-            1. inputタブで画像を選択します。
-            2. Submitボタンを押します。
-               ※画像は外部送信していません。ローカルで処理が完結します。
-            3. 結果は、JETタブとHOTタブに表示します。  
+            gr.Markdown("""
+                1. inputタブで画像を選択します。
+                2. Submitボタンを押します。
+                   ※画像は外部送信していません。ローカルで処理が完結します。
+                3. 結果は、JETタブとHOTタブに表示します。  
             """)
-
-        algorithmType = gr.Radio(["SpectralResidual", "FineGrained"], label="Saliency", value="SpectralResidual", interactive=True)
+        algorithm_type = gr.Radio(
+            ["SpectralResidual", "FineGrained"],
+            label="Saliency",
+            value="SpectralResidual",
+            interactive=True
+        )
 
         submit_button = gr.Button("submit", variant="primary")
 
         with gr.Row():
             with gr.Tab("input", id="input"):
 
-                image_input = gr.Image(sources = ["upload", "clipboard"], interactive=True)
+                image_input = gr.Image(sources=["upload", "clipboard"],
+                                       interactive=True)
             with gr.Tab("overlay(JET)"):
                 image_overlay_jet = gr.Image(interactive=False)
-                #tab_jet.select(jetTab_Selected, inputs=[image_input], outputs=image_overlay_jet)
+                # tab_jet.select(jetTab_Selected, inputs=[image_input], outputs=image_overlay_jet)
             with gr.Tab("overlay(HOT)"):
                 image_overlay_hot = gr.Image(interactive=False)
-                #tab_hot.select(hotTab_Selected, inputs=[image_input], outputs=image_overlay_hot, api_name=False)
-        
-        submit_button.click(submit_Clicked, inputs=[image_input, algorithmType], outputs=[image_overlay_jet, image_overlay_hot])
-
-        gr.Markdown(
-        f"""
-        Python {sys.version}  
-        App {__version__}  
+                # tab_hot.select(hotTab_Selected,
+                # inputs=[image_input],
+                # outputs=image_overlay_hot, api_name=False)
+        #
+        submit_button.click(
+            submit_clicked,
+            inputs=[image_input, algorithm_type],
+            outputs=[image_overlay_jet,
+                     image_overlay_hot]
+        )
+
+        gr.Markdown(f"""
+            Python {sys.version}  
+            App {__version__}  
         """)
-        
+
         demo.queue(default_concurrency_limit=5)
-        
+
         log.info(f"#アプリ起動完了({watch.stop():.3f}s)")
         # https://www.gradio.app/docs/gradio/blocks#blocks-launch
-        
         demo.launch(
-            max_file_size=args.max_file_size,
-            server_port=args.server_port,
             inbrowser=args.inbrowser,
             share=args.share,
+            server_port=args.server_port,
+            max_file_size=args.max_file_size,
         )
-

src/reporter.py

@@ -4,7 +4,7 @@
     ログハンドラーが重複登録されるのを防ぐために1箇所で生成してログハンドラーを返します。
     Example:
         from reporter import get_current_reporter
-        
+
         logger = get_current_reporter()
         logger.info("message");
 """
@@ -13,37 +13,45 @@ from logging import DEBUG
 
 _reporters = []
 
+
 def get_current_reporter() -> Logger:
+    """
+    シングルトン
+    """
     return _reporters[-1]
 
-def __make_reporter(name: str='SaliencyMapDemo') -> None:
+
+def __make_reporter(name: str = 'SaliencyMapDemo') -> None:
     """
     ログハンドラーを生成します。
-    @see https://docs.python.jp/3/howto/logging-cookbook.html#logging-to-a-single-file-from-multiple-processes
-    
+    @see https://docs.python.jp/3/howto/logging-cookbook.html
+
     Parameters:
         name: アプリ名
     """
-    handler = StreamHandler() # コンソールに出力します。
+    handler = StreamHandler()  # コンソールに出力します。
     formatter = Formatter('%(asctime)s%(message)s')
     handler.setFormatter(formatter)
     handler.setLevel(DEBUG)
-    
+
     logger = getLogger(name)
     logger.setLevel(DEBUG)
     logger.addHandler(handler)
     _reporters.append(logger)
 
+
 __make_reporter()
 
+
 def main():
     """
         Entry Point
     """
     assert len(_reporters) == 1
-    
+
     logger = get_current_reporter()
     logger.debug("main")
 
+
 if __name__ == "__main__":
     main()

src/saliency.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
-from typing import Literal
+"""SaliencyMapを計算する"""
+from typing import Any, Tuple, Literal
 
 import numpy as np
 import cv2
@@ -10,23 +11,22 @@ class SaliencyMap:
     SaliencyMap 顕著性マップを計算するクラスです。
     Example:
         from lib.saliency import SaliencyMap
-        
+
         saliency = SaliencyMap("SpectralResidual")
-        success, saliencyMap = saliency.computeSaliency(image)
+        success, saliencyMap = saliency.compute(image)
     """
     def __init__(
         self,
         algorithm: Literal["SpectralResidual", "FineGrained"] = "SpectralResidual",
-        ):
+    ):
         self.algorithm = algorithm
         # OpenCVのsaliencyを作成します。
         if algorithm == "SpectralResidual":
             self.saliency = cv2.saliency.StaticSaliencySpectralResidual_create()
         else:
             self.saliency = cv2.saliency.StaticSaliencyFineGrained_create()
-        
 
-    def computeSaliency(self, image: np.ndarray):
+    def compute(self, image: np.ndarray) -> Tuple[bool, Any]:
         """
         入力画像から顕著性マップを作成します。
 
@@ -41,31 +41,32 @@ class SaliencyMap:
         # 画像の顕著性を計算します。
         return self.saliency.computeSaliency(image)
 
-def convertColorMap(
+
+def convert_colormap(
     image: np.ndarray,
-    saliencyMap: np.ndarray,
-    colormap_name: Literal["jet", "hot", "turbo"] = "jet"):
+    saliency_map: np.ndarray,
+    colormap_name: Literal["jet", "hot", "turbo"] = "jet"
+):
     """
     顕著性マップをカラーマップに変換後に、入力画像に重ね合わせします。
-    
+
     Parameters:
         image: 入力画像
-        saliencyMap: 顕著性マップ
+        saliency_map: 顕著性マップ
         colormap_name: カラーマップの種類
 
     Returns:
         np.ndarray: 重ね合わせた画像(RGBA形式)
     """
-    colormaps = {"jet": cv2.COLORMAP_JET, "hot": cv2.COLORMAP_HOT, "turbo": cv2.COLORMAP_TURBO}
-    if colormap_name not in colormaps:
-        raise ValueError(colormap_name) 
+    maps = {"jet": cv2.COLORMAP_JET, "hot": cv2.COLORMAP_HOT, "turbo": cv2.COLORMAP_TURBO}
+    if colormap_name not in maps:
+        raise ValueError(colormap_name)
 
     # 顕著性マップをカラーマップに変換
-    saliencyMap = (saliencyMap * 255).astype("uint8")
-    saliencyMap = cv2.applyColorMap(saliencyMap, colormaps[colormap_name])
+    saliency_map = (saliency_map * 255).astype("uint8")
+    saliency_map = cv2.applyColorMap(saliency_map, maps[colormap_name])
     #return saliencyMap
     # 入力画像とカラーマップを重ね合わせ
-    overlay = cv2.addWeighted(image, 0.5, saliencyMap, 0.5, 0)
+    overlay = cv2.addWeighted(image, 0.5, saliency_map, 0.5, 0)
     #return overlay
-    
     return cv2.cvtColor(overlay, cv2.COLOR_BGR2RGBA)

src/utils.py

@@ -1,39 +1,57 @@
 # -*- coding: utf-8 -*-
+"""ユーティリティ"""
 import time
 
+
 def get_package_version() -> str:
+    """
+    バージョン情報
+    """
     return '0.0.4'
 
+
 class Stopwatch:
     """
     Stopwatch 経過時間を計測するためのクラスです。
     Example:
-        from utils import Stopwatch
-        
-        watch = Stopwatch.startNew()
+        from src.utils import Stopwatch
+
+        watch = Stopwatch.start_new()
         # 計測する処理
         print(f"{watch.stop():.3f}")
     """
 
     def __init__(self):
-        self._start_time = None
-        self._elapsed = 0;
+        self._start_time = 0
+        self._elapsed = 0
 
     @property
-    def Elapsed(self):
+    def elapsed(self):
+        """
+        経過時間
+        """
         return self._elapsed
 
     def start(self) -> None:
+        """
+        計測を開始します。
+        """
         self._start_time = time.perf_counter()
-        self._elapsed = 0;
+        self._elapsed = 0
 
     @classmethod
-    def startNew(cls):
+    def start_new(cls):
+        """
+        ストップウォッチを生成し計測を開始します。
+        """
         stopwatch = Stopwatch()
         stopwatch.start()
         return stopwatch
 
     def stop(self):
+        """
+        計測を終了します。
+        """
         end_time = time.perf_counter()
         self._elapsed = end_time - self._start_time
         return self._elapsed

test/test_create_grayscale_gradation.py

@@ -1,14 +1,21 @@
 # -*- coding: utf-8 -*-
+"""単体テストモジュール"""
 import unittest
 
 import numpy as np
 from PIL import Image
 
+
 class TestGrayscale(unittest.TestCase):
-    pass
+    """
+    グレースケールのテスト
+    """
 
 
 def main():
+    """
+    単体テストのエントリーポイント
+    """
     # グラデーションのサイズを定義します
     width = 256
     height = 256
@@ -25,6 +32,7 @@ def main():
     # 画像を表示します
     image.show()
 
+
 if __name__ == "__main__":
     #main()
     unittest.main()