Add webcam

Author: tae898

README.md

@@ -187,7 +187,7 @@ There are three training steps involved.
 
 1. Five random seeds on 5-fold cross-validation on the `Adience` dataset.
 
-   Since the reported metrics (i.e. accuracy) is 5-fold cross-validation, we will do the same here. In order to get the least biased numbers, we run this five times each with a different seed. This means that we are training in total of 25 times and report the average of the 25 numbers. Configure the values in `cross-val.json` and run `python cross-val.py`.
+   Since the reported metrics (i.e., accuracy) is 5-fold cross-validation, we will do the same here. In order to get the least biased numbers, we run this five times each with a different seed. This means that we are training in total of 25 times and report the average of the 25 numbers. Configure the values in `cross-val.json` and run `python cross-val.py`.
 
 ## [Evaluation results](training-results/TRAINING-RESULTS.md)
 
@@ -257,9 +257,29 @@ Check out [this demo video](https://youtu.be/Dna_Hp-s78I).
    python3 app.py
    ```
 
-After running the container (i.e. `docker run -it --rm -p 10003:10003 tae898/age-gender`), you can run `client.py` (e.g. `python client.py --image-path test-images/matrix-tae-final_exported_37233.jpg`) to get estimated genders and ages in the picture.
+### Running a client
 
-NB: You also have to run the face-detection-recognition (`docker run -it --rm -p 10002:10002 tae898/face-detection-recognition` for CPU or `docker run --gpus all -it --rm -p 10002:10002 tae898/face-detection-recognition-cuda` for cuda), before running `client.py`. This separation might be annoying but the modularization will help in the future.
+First install the requirements by running `pip install requirements-client.txt`, and then run the two containers:
+
+1. `docker run -it --rm -p 10002:10002 tae898/face-detection-recognition` for CPU or `docker run --gpus all -it --rm -p 10002:10002 tae898/face-detection-recognition-cuda` for cuda.
+1. `docker run -it --rm -p 10003:10003 tae898/age-gender` for CPU or `docker run -it --rm -p 10003:10003 --gpus all tae898/age-gender-cuda` for cuda.
+
+Now that the two containers are running, you can run `client.py`. There are two options to run the client.
+
+```sh
+usage: client.py [-h] [--url-face URL_FACE] [--url-age-gender URL_AGE_GENDER]
+                 [--image-path IMAGE_PATH] [--camera-id CAMERA_ID]
+                 [--mode MODE]
+```
+
+1. If you have an image stored in disk and want to run the models on this image, then do something like:
+   ```sh
+   python client.py --mode image --image-path test-images/gettyimages-1067881118-2048x2048.jpg
+   ```
+1. If you want to run the models on your webcam video, then do something like:
+   ```sh
+   python client.py --mode webcam
+   ```
 
 ## Troubleshooting
 

client.py

@@ -18,17 +18,20 @@
 )
 
 
-def main(url_face: str, url_age_gender: str, image_path: str):
+def send_to_servers(binary_image, url_face: str, url_age_gender: str) -> None:
+    """Send a binary image to the two servers.
 
-    logging.debug(f"loading image ...")
-    if isinstance(image_path, str):
-        with open(image_path, "rb") as stream:
-            binary_image = stream.read()
-    elif isinstance(image_path, Image.Image):
-        binary_image = io.BytesIO()
-        image_path.save(binary_image, format="JPEG")
-        binary_image = binary_image.getvalue()
+    Args
+    ----
+    binary_image: binary image
+    url_face: url of the face-detection-recognition server
+    url_age_gender: url of the age-gender server.
 
+    Returns
+    -------
+    genders, ages, bboxes, det_scores, landmarks, embeddings
+
+    """
     data = {"image": binary_image}
     logging.info(f"image loaded!")
 
@@ -60,8 +63,20 @@ def main(url_face: str, url_age_gender: str, image_path: str):
     ages = response["ages"]
     genders = response["genders"]
 
+    return genders, ages, bboxes, det_scores, landmarks, embeddings
+
+
+def annotate_image(image: Image.Image, genders: list, ages: list, bboxes: list) -> None:
+    """Annotate a given image. This is done in-place. Nothing is returned.
+
+    Args
+    ----
+    image: Pillow image
+    genders, ages, bboxes
+
+    """
     logging.debug(f"annotating image ...")
-    image = Image.open(image_path)
+
     draw = ImageDraw.Draw(image)
     font = ImageFont.truetype("fonts/arial.ttf", 25)
 
@@ -83,8 +98,33 @@ def main(url_face: str, url_age_gender: str, image_path: str):
             fill=(0, 255, 0),
             font=font,
         )
-        image.save(image_path + ".ANNOTATED.jpg")
-    logging.info(f"image annotated and saved at {image_path + '.ANNOTATED.jpg'}")
+
+
+def save_annotated_image(
+    image: Image.Image,
+    save_path: str,
+    bboxes: list,
+    det_scores: list,
+    landmarks: list,
+    embeddings: list,
+    genders: list,
+    ages: list,
+) -> None:
+    """Save the annotated image.
+
+    Args
+    ----
+    image: Pilow image
+    bboxes:
+    det_scores:
+    landmarks:
+    embeddings:
+    genders:
+    ages:
+
+    """
+    image.save(save_path)
+    logging.info(f"image annotated and saved at {save_path}")
 
     to_dump = {
         "bboxes": bboxes,
@@ -95,19 +135,122 @@ def main(url_face: str, url_age_gender: str, image_path: str):
         "ages": ages,
     }
 
-    with open(image_path + ".pkl", "wb") as stream:
+    with open(save_path + ".pkl", "wb") as stream:
         pickle.dump(to_dump, stream)
-    logging.info(f"features saved at at {image_path + '.pkl'}")
+    logging.info(f"features saved at at {save_path + '.pkl'}")
+
+
+def run_image(url_face: str, url_age_gender: str, image_path: str):
+    """Run age-gender on the image.
+
+    Args
+    ----
+    url_face: url of the face-detection-recognition server
+    url_age_gender: url of the age-gender server.
+    image_path
+
+    """
+    logging.debug(f"loading image ...")
+    with open(image_path, "rb") as stream:
+        binary_image = stream.read()
+
+    genders, ages, bboxes, det_scores, landmarks, embeddings = send_to_servers(
+        binary_image, url_face, url_age_gender
+    )
+
+    image = Image.open(image_path)
+
+    annotate_image(image, genders, ages, bboxes)
+
+    save_path = image_path + ".ANNOTATED.jpg"
+
+    save_annotated_image(
+        image, save_path, bboxes, det_scores, landmarks, embeddings, genders, ages
+    )
+
+
+def annotate_fps(image: Image.Image, fps: int) -> None:
+    """Annotate fps on a given image.
+
+    Args
+    ----
+    image: Pillow image
+    fps: frames per second
+
+    """
+    draw = ImageDraw.Draw(image)
+    font = ImageFont.truetype("fonts/arial.ttf", 25)
+    draw.text((0, 0), f"FPS: {fps} (Press q  to exit.)", fill=(0, 0, 255), font=font)
+
+
+def run_webcam(url_face: str, url_age_gender: str, camera_id: int):
+
+    import time
+
+    import cv2
+
+    cap = cv2.VideoCapture(camera_id)
+
+    if not cap.isOpened():
+        print("Cannot open camera")
+        exit()
+
+    # fps = []
+    while True:
+        start_time = time.time()  # start time of the loop
+        # Capture frame-by-frame
+        ret, image_BGR = cap.read()
+        # if frame is read correctly ret is True
+        if not ret:
+            print("Can't receive frame (stream end?). Exiting ...")
+            break
+        # Our operations on the frame come here
+        # gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        # Display the resulting frame
+        image_RGB = cv2.cvtColor(image_BGR, cv2.COLOR_BGR2RGB)
+
+        image_PIL = Image.fromarray(image_RGB)
+        binary_image = io.BytesIO()
+        image_PIL.save(binary_image, format="JPEG")
+        binary_image = binary_image.getvalue()
+
+        genders, ages, bboxes, det_scores, landmarks, embeddings = send_to_servers(
+            binary_image, url_face, url_age_gender
+        )
+
+        annotate_image(image_PIL, genders, ages, bboxes)
+
+        # fps.append(time)
+        fps = int(1.0 / (time.time() - start_time))
+
+        annotate_fps(image_PIL, fps)
+
+        cv2.imshow("frame", cv2.cvtColor(np.array(image_PIL), cv2.COLOR_RGB2BGR))
+        if cv2.waitKey(1) == ord("q"):
+            break
+
+    # When everything done, release the capture
+    cap.release()
+    cv2.destroyAllWindows()
 
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Extract face, gender, and age.")
     parser.add_argument("--url-face", type=str, default="http://127.0.0.1:10002/")
     parser.add_argument("--url-age-gender", type=str, default="http://127.0.0.1:10003/")
-    parser.add_argument("--image-path", type=str)
+    parser.add_argument("--image-path", type=str, default=None)
+    parser.add_argument("--camera-id", type=int, default="0", help="ffplay /dev/video0")
+    parser.add_argument("--mode", type=str, default="image", help="image or webcam")
 
     args = vars(parser.parse_args())
 
     logging.info(f"arguments given to {__file__}: {args}")
 
-    main(**args)
+    mode = args.pop("mode")
+    if mode == "image":
+        assert args["image_path"] is not None
+        del args["camera_id"]
+        run_image(**args)
+    else:
+        del args["image_path"]
+        run_webcam(**args)

requirements-client.txt

@@ -1,10 +1,12 @@
-charset-normalizer==2.0.4
-idna==3.2
-importlib-metadata==4.8.1
-jsonpickle==2.0.0
-numpy==1.21.2
-Pillow==8.3.2
-requests==2.26.0
-typing-extensions==3.10.0.2
-urllib3==1.26.6
-zipp==3.5.0
+certifi==2021.10.8
+charset-normalizer==2.0.11
+idna==3.3
+importlib-metadata==4.10.1
+jsonpickle==2.1.0
+numpy==1.21.5
+opencv-python==4.5.5.62
+Pillow==9.0.1
+requests==2.27.1
+typing_extensions==4.0.1
+urllib3==1.26.8
+zipp==3.7.0