- first pass as rename and dependency update
authorEric Zavesky <ezavesky@research.att.com>
Tue, 14 Nov 2017 03:58:32 +0000 (21:58 -0600)
committerEric Zavesky <ezavesky@research.att.com>
Tue, 14 Nov 2017 03:58:32 +0000 (21:58 -0600)
README.md
face_privacy_filter/_version.py
face_privacy_filter/filter_image.py
face_privacy_filter/transform_detect.py
face_privacy_filter/transform_region.py
setup.py
testing/app.py
web_demo/face-privacy.js

index 580bc45..bba12b1 100644 (file)
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 A model for face detection and suppression.
 
 ## Image Analysis for Face-based Privacy Filtering
-This source code creates and pushes a model into Cognita that processes
+This source code creates and pushes a model into Acumos that processes
 incoming images and outputs a detected faces as well as the original image
 input (if configured that way).  The model uses a [python interface](https://pypi.python.org/pypi/opencv-python)
 to the [OpenCV library](https://opencv.org/) to detect faces and perform
@@ -62,7 +62,30 @@ composed together for operation.
 ./bin/run_local.sh -d model_pix -i detect.csv -p output.jpg --csv_input
 ```
 
+### Installation Troubleshoting
+Using some environment-based versions of python (e.g. conda),
+one problem seemed to come up with the installation of the dependent
+package `opencv-python`.  If you launch your python instance and see
+an error like the one below, keep reading.
 
+```
+>>> import cv2
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+ImportError: dynamic module does not define module export function (PyInit_cv2)
+>>>
+```
+
+This is likely because your `PYTHONPATH` is not correctly configured to
+point to the additional installed libraries.
+
+* From the [simple example here](https://stackoverflow.com/a/42160595)
+you can check your environment with `echo $PYTHONPATH`.  If it does not
+contain the directory that you installed to, then you have a problem.
+* Please check your installation by running `python -v -v; import cv2` and checking
+that the last loaded library is in the right location.
+* In some instances, this variable needed to be blank to work properly (i.e.
+`export PYTHONPATH=`) run at some time during start up.
 
 ## Face-based Use Cases
 This project includes a number of face-based use cases including raw
@@ -74,7 +97,7 @@ incoming images and outputs detected faces.
 
 # Example Interface
 An instance should first be built and downloaded and then
-launched locally.  Afterwards, the sample application found in 
+launched locally.  Afterwards, the sample application found in
 [web_demo](web_demo) uses a `localhost` service to classify
 and visualize the results of image classification.
 
index 38c9a1d..592027f 100644 (file)
@@ -1,3 +1,3 @@
 # -*- coding: utf-8 -*-
-__version__ = "0.1.3"
+__version__ = "0.2.0"
 MODEL_NAME = 'face_privacy_filter'
index 352b87a..2c4ca59 100644 (file)
@@ -1,7 +1,7 @@
 #! python
 # -*- coding: utf-8 -*-
 """
-Wrapper for image emotion classification task 
+Wrapper for image emotion classification task
 """
 
 import os.path
@@ -15,26 +15,37 @@ from face_privacy_filter.transform_region import RegionTransform
 from face_privacy_filter._version import MODEL_NAME
 
 
-def model_create_pipeline(transformer, pipeline_type="detect"):
-    #from sklearn.pipeline import Pipeline
-    dependent_modules = [pd, np, 'opencv-python']  # define as dependent libraries
+def model_create_pipeline(transformer):
+    from acumos.modeling import Model
+    from acumos.session import Requirements
+    import sklearn
+    import cv2
+    from os import path
 
-    # for now, do nothing specific to transformer...
+    type_in = transformer._acumos_type_in
+    type_out = transformer._acumos_type_out
 
-    return transformer, dependent_modules
+    def predict_class(df: type_in) -> type_out:
+        '''Returns an array of float predictions'''
+        return transformer.predict(df)
+
+    # compute path of this package to add it as a dependency
+    package_path = path.dirname(path.realpath(__file__))
+    return Model(classify=predict_class), Requirements(packages=[package_path], reqs=[pd, np, sklearn],
+                                                       req_map={cv2: 'opencv-python'})
 
 
 def main(config={}):
     import argparse
     parser = argparse.ArgumentParser()
     parser.add_argument('-p', '--predict_path', type=str, default='', help="save detections from model (model must be provided via 'dump_model')")
-    parser.add_argument('-i', '--input', type=str, default='',help='absolute path to input data (image or csv, only during prediction / dump)')
+    parser.add_argument('-i', '--input', type=str, default='', help='absolute path to input data (image or csv, only during prediction / dump)')
     parser.add_argument('-c', '--csv_input', dest='csv_input', action='store_true', default=False, help='input as CSV format not an image')
     parser.add_argument('-s', '--suppress_image', dest='suppress_image', action='store_true', default=False, help='do not create an extra row for a returned image')
-    parser.add_argument('-f', '--function', type=str, default='detect',help='which type of model to generate', choices=['detect', 'pixelate'])
+    parser.add_argument('-f', '--function', type=str, default='detect', help='which type of model to generate', choices=['detect', 'pixelate'])
     parser.add_argument('-a', '--push_address', help='server address to push the model (e.g. http://localhost:8887/v2/models)', default='')
     parser.add_argument('-d', '--dump_model', help='dump model to a pickle directory for local running', default='')
-    config.update(vars(parser.parse_args()))     #pargs, unparsed = parser.parse_known_args()
+    config.update(vars(parser.parse_args()))     # pargs, unparsed = parser.parse_known_args()
 
     if not config['predict_path']:
         print("Attempting to create new model for dump or push...")
@@ -47,19 +58,24 @@ def main(config={}):
         else:
             print("Error: Functional mode '{:}' unknown, aborting create".format(config['function']))
         inputDf = transform.generate_in_df()
-        pipeline, EXTRA_DEPS = model_create_pipeline(transform, "detect")
+        pipeline, reqs = model_create_pipeline(transform)
 
         # formulate the pipeline to be used
-        model_name = MODEL_NAME+"_"+config['function']
+        model_name = MODEL_NAME + "_" + config['function']
         if 'push_address' in config and config['push_address']:
-            from cognita_client.push import push_sklearn_model # push_skkeras_hybrid_model (keras?)
+            from acumos.session import AcumosSession
             print("Pushing new model to '{:}'...".format(config['push_address']))
-            push_sklearn_model(pipeline, inputDf, api=config['push_address'], name=model_name, extra_deps=EXTRA_DEPS)
+            session = AcumosSession(push_api=config['push_address'], auth_api=config['auth_address'])
+            session.push(pipeline, model_name, reqs)  # creates ./my-iris.zip
 
         if 'dump_model' in config and config['dump_model']:
-            from cognita_client.wrap.dump import dump_sklearn_model # dump_skkeras_hybrid_model (keras?)
+            from acumos.session import AcumosSession
+            from os import makedirs
+            if not os.path.exists(config['dump_model']):
+                makedirs(config['dump_model'])
             print("Dumping new model to '{:}'...".format(config['dump_model']))
-            dump_sklearn_model(pipeline, inputDf, config['dump_model'], name=model_name, extra_deps=EXTRA_DEPS)
+            session = AcumosSession()
+            session.dump(pipeline, model_name, config['dump_model'], reqs)  # creates ./my-iris.zip
 
     else:
         if not config['dump_model'] or not os.path.exists(config['dump_model']):
@@ -70,13 +86,14 @@ def main(config={}):
             sys.exit(-1)
 
         print("Attempting predict/transform on input sample...")
-        from cognita_client.wrap.load import load_model
+        from acumos.wrapped import load_model
         model = load_model(config['dump_model'])
         if not config['csv_input']:
             inputDf = FaceDetectTransform.generate_in_df(config['input'])
         else:
-            inputDf = pd.read_csv(config['input'], converters={FaceDetectTransform.COL_IMAGE_DATA:FaceDetectTransform.read_byte_arrays})
-        dfPred = model.transform.from_native(inputDf).as_native()
+            inputDf = pd.read_csv(config['input'], converters={FaceDetectTransform.COL_IMAGE_DATA: FaceDetectTransform.read_byte_arrays})
+        dfPred = model.transform.from_native(inputDf).as_wrapped()
+        dfPred = dfPred[0]
 
         if config['predict_path']:
             print("Writing prediction to file '{:}'...".format(config['predict_path']))
@@ -90,5 +107,6 @@ def main(config={}):
         if dfPred is not None:
             print("Predictions:\n{:}".format(dfPred))
 
+
 if __name__ == '__main__':
     main()
index 9dc35f5..1daf3c2 100644 (file)
@@ -10,6 +10,7 @@ import numpy as np
 from sklearn.base import BaseEstimator, ClassifierMixin
 import base64
 
+
 class FaceDetectTransform(BaseEstimator, ClassifierMixin):
     '''
     A sklearn transformer mixin that detects faces and optionally outputa the original detected image
@@ -22,13 +23,13 @@ class FaceDetectTransform(BaseEstimator, ClassifierMixin):
     COL_REGION_IDX = 'region'
     COL_IMAGE_IDX = 'image'
     COL_IMAGE_MIME = 'mime_type'
-    COL_IMAGE_DATA = 'base64_data'
+    COL_IMAGE_DATA = 'image_binary'
     VAL_REGION_IMAGE_ID = -1
 
     def __init__(self, cascade_path=None, include_image=True):
         self.include_image = include_image    # should output transform include image?
         self.cascade_path = cascade_path    # abs path outside of module
-        self.cascade_obj = None # late-load this component
+        self.cascade_obj = None  # late-load this component
 
     def get_params(self, deep=False):
         return {'include_image': self.include_image}
@@ -38,9 +39,6 @@ class FaceDetectTransform(BaseEstimator, ClassifierMixin):
         # munge stream and mimetype into input sample
         if path_image and os.path.exists(path_image):
             bin_stream = open(path_image, 'rb').read()
-        bin_stream = base64.b64encode(bin_stream)
-        if type(bin_stream) == bytes:
-            bin_stream = bin_stream.decode()
         return pd.DataFrame([['image/jpeg', bin_stream]], columns=[FaceDetectTransform.COL_IMAGE_MIME, FaceDetectTransform.COL_IMAGE_DATA])
 
     @staticmethod
@@ -50,11 +48,11 @@ class FaceDetectTransform(BaseEstimator, ClassifierMixin):
             f.write(row[FaceDetectTransform.COL_IMAGE_DATA][0])
 
     @staticmethod
-    def generate_out_dict(idx=VAL_REGION_IMAGE_ID, x=0, y=0, w=0, h=0, image=0):
-        return {FaceDetectTransform.COL_REGION_IDX: idx, FaceDetectTransform.COL_FACE_X: x,
-                FaceDetectTransform.COL_FACE_Y: y, FaceDetectTransform.COL_FACE_W: w, FaceDetectTransform.COL_FACE_H: h,
-                FaceDetectTransform.COL_IMAGE_IDX: image,
-                FaceDetectTransform.COL_IMAGE_MIME: '', FaceDetectTransform.COL_IMAGE_DATA: ''}
+    def generate_out_dict(idx=VAL_REGION_IMAGE_ID, x=0, y=0, w=0, h=0, image=0, bin_stream=b"", media=""):
+        return {FaceDetectTransform.COL_IMAGE_IDX: image, FaceDetectTransform.COL_REGION_IDX: idx,
+                FaceDetectTransform.COL_FACE_X: x, FaceDetectTransform.COL_FACE_Y: y,
+                FaceDetectTransform.COL_FACE_W: w, FaceDetectTransform.COL_FACE_H: h,
+                FaceDetectTransform.COL_IMAGE_MIME: media, FaceDetectTransform.COL_IMAGE_DATA: bin_stream}
 
     @staticmethod
     def suppress_image(df):
@@ -64,28 +62,29 @@ class FaceDetectTransform(BaseEstimator, ClassifierMixin):
                     FaceDetectTransform.COL_REGION_IDX, FaceDetectTransform.COL_IMAGE_IDX]
         blank_cols = [col for col in df.columns if col not in keep_col]
         # set columns that aren't in our known column list to empty strings; search where face index==-1 (no face)
-        df.loc[df[FaceDetectTransform.COL_REGION_IDX]==FaceDetectTransform.VAL_REGION_IMAGE_ID,blank_cols] = ""
+        df.loc[df[FaceDetectTransform.COL_REGION_IDX] == FaceDetectTransform.VAL_REGION_IMAGE_ID, blank_cols] = ""
         return df
 
     @property
-    def output_names_(self):
-        return [FaceDetectTransform.COL_REGION_IDX, FaceDetectTransform.COL_FACE_X, FaceDetectTransform.COL_FACE_Y,
-                 FaceDetectTransform.COL_FACE_W, FaceDetectTransform.COL_FACE_H,
-                 FaceDetectTransform.COL_IMAGE_IDX, FaceDetectTransform.COL_IMAGE_MIME, FaceDetectTransform.COL_IMAGE_DATA]
-
-    @property
-    def output_types_(self):
-        list_name = self.output_names_
-        list_type = self.classes_
-        return [{list_name[i]:list_type[i]} for i in range(len(list_name))]
+    def _acumos_type_in(self):
+        """Custom input type for this processing transformer"""
+        from acumos.modeling import List, create_namedtuple
+        # base input for detect is image itself
+        ImageRow = create_namedtuple('ImageRow', [(FaceDetectTransform.COL_IMAGE_MIME, str),
+                                                  (FaceDetectTransform.COL_IMAGE_DATA, bytes)])
+        # represents a collection of flattened image arrays
+        return List[ImageRow]
 
     @property
-    def n_outputs_(self):
-        return 8
-
-    @property
-    def classes_(self):
-        return [int, int, int, int, int, int, str, str]
+    def _acumos_type_out(self):
+        """Custom input type for this processing transformer"""
+        from acumos.modeling import List, create_namedtuple
+        output_dict = FaceDetectTransform.generate_out_dict()
+        tuple_types = [(k, type(output_dict[k])) for k in output_dict]
+        # base output for detect is several parts
+        DetectionRow = create_namedtuple('DetectionRow', tuple_types)
+        # represents a collection of flattened image arrays
+        return List[DetectionRow]
 
     def score(self, X, y=None):
         return 0
@@ -96,7 +95,7 @@ class FaceDetectTransform(BaseEstimator, ClassifierMixin):
     def predict(self, X, y=None):
         """
         Assumes a numpy array of [[mime_type, binary_string] ... ]
-           where mime_type is an image-specifying mime type and binary_string is the raw image bytes       
+           where mime_type is an image-specifying mime type and binary_string is the raw image bytes
         """
         # if no model exists yet, create it
         if self.cascade_obj is None:
@@ -110,7 +109,7 @@ class FaceDetectTransform(BaseEstimator, ClassifierMixin):
         dfReturn = None
         for image_idx in range(len(X)):
             image_byte = X[FaceDetectTransform.COL_IMAGE_DATA][image_idx]
-            if type(image_byte)==str:
+            if type(image_byte) == str:
                 image_byte = image_byte.encode()
             image_byte = bytearray(base64.b64decode(image_byte))
             file_bytes = np.asarray(image_byte, dtype=np.uint8)
@@ -127,18 +126,19 @@ class FaceDetectTransform(BaseEstimator, ClassifierMixin):
             for idxF in range(len(faces)):  # walk through detected faces
                 face_rect = faces[idxF]
                 df = df.append(pd.DataFrame([FaceDetectTransform.generate_out_dict(idxF, face_rect[0], face_rect[1],
-                                                                    face_rect[2], face_rect[3], image=image_idx)]),
+                                                                                   face_rect[2], face_rect[3], image=image_idx)]),
                                ignore_index=True)
             if dfReturn is None:  # create an NP container for all image samples + features
                 dfReturn = df.reindex_axis(self.output_names_, axis=1)
             else:
                 dfReturn = dfReturn.append(df, ignore_index=True)
-            #print("IMAGE {:} found {:} total rows".format(image_idx, len(df)))
+            # print("IMAGE {:} found {:} total rows".format(image_idx, len(df)))
 
         return dfReturn
 
     def detect_faces(self, img):
-        if self.cascade_obj is None: return []
+        if self.cascade_obj is None:
+            return []
         gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
         faces = self.cascade_obj.detectMultiScale(
@@ -150,8 +150,6 @@ class FaceDetectTransform(BaseEstimator, ClassifierMixin):
         )
 
         # Draw a rectangle around the faces
-        #for (x, y, w, h) in faces:
+        # for (x, y, w, h) in faces:
         #    cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
         return faces
-
-# FaceDetectTransform.__module__ = '__main__'
\ No newline at end of file
index 1ff7f26..59a8dc5 100644 (file)
@@ -4,7 +4,6 @@
 Wrapper for region processing task; wrapped in classifier for pipieline terminus
 """
 import cv2
-import os
 import pandas as pd
 import numpy as np
 from sklearn.base import BaseEstimator, ClassifierMixin
@@ -12,12 +11,16 @@ import base64
 
 # NOTE: If this class were built in another model (e.g. another vendor, class, etc), we would need to
 #       *exactly match* the i/o for the upstream (detection) and downstream (this processing)
+# from face_privacy_filter.transform_detect import RegionTransform
+
 from face_privacy_filter.transform_detect import FaceDetectTransform
 
+
 class RegionTransform(BaseEstimator, ClassifierMixin):
     '''
     A sklearn classifier mixin that manpulates image content based on input
     '''
+    CASCADE_DEFAULT_FILE = "data/haarcascade_frontalface_alt.xml.gz"
 
     def __init__(self, transform_mode="pixelate"):
         self.transform_mode = transform_mode    # specific image processing mode to utilize
@@ -27,37 +30,37 @@ class RegionTransform(BaseEstimator, ClassifierMixin):
 
     @staticmethod
     def generate_out_df(media_type="", bin_stream=b""):
-        # munge stream and mimetype into input sample
-        bin_stream = base64.b64encode(bin_stream)
-        if type(bin_stream)==bytes:
-            bin_stream = bin_stream.decode()
         return pd.DataFrame([[media_type, bin_stream]], columns=[FaceDetectTransform.COL_IMAGE_MIME, FaceDetectTransform.COL_IMAGE_DATA])
 
     @staticmethod
     def generate_in_df(idx=FaceDetectTransform.VAL_REGION_IMAGE_ID, x=0, y=0, w=0, h=0, image=0, bin_stream=b"", media=""):
-        return pd.DataFrame([[idx,x,y,w,h,image,media,bin_stream]],
-                            columns=[FaceDetectTransform.COL_REGION_IDX, FaceDetectTransform.COL_FACE_X, FaceDetectTransform.COL_FACE_Y,
-                                     FaceDetectTransform.COL_FACE_W, FaceDetectTransform.COL_FACE_H,
-                                     FaceDetectTransform.COL_IMAGE_IDX, FaceDetectTransform.COL_IMAGE_MIME,
-                                     FaceDetectTransform.COL_IMAGE_DATA])
-
-    @property
-    def output_names_(self):
-        return [FaceDetectTransform.COL_IMAGE_MIME, FaceDetectTransform.COL_IMAGE_DATA]
+        return pd.DataFrame([], RegionTransform.generate_in_dict(idx=idx, x=x, y=y, h=h, w=w, image=image, bin_stream=bin_stream, media=media))
 
-    @property
-    def output_types_(self):
-        list_name = self.output_names_
-        list_type = self.classes_
-        return [{list_name[i]:list_type[i]} for i in range(len(list_name))]
+    @staticmethod
+    def generate_in_dict(idx=FaceDetectTransform.VAL_REGION_IMAGE_ID, x=0, y=0, w=0, h=0, image=0, bin_stream=b"", media=""):
+        return FaceDetectTransform.generate_out_dict(idx=idx, x=x, y=y, h=h, w=w, image=image, bin_stream=bin_stream, media=media)
 
     @property
-    def n_outputs_(self):
-        return 8
+    def _acumos_type_in(self):
+        """Custom input type for this processing transformer"""
+        from acumos.modeling import List, create_namedtuple
+        # base input for detect is image itself
+        input_dict = RegionTransform.generate_in_dict()
+        tuple_types = [(k, type(input_dict[k])) for k in input_dict]
+        # base output for detect is several parts
+        DetectionRow = create_namedtuple('DetectionRow', tuple_types)
+        # represents a collection of flattened detect arrays
+        return List[DetectionRow]
 
     @property
-    def classes_(self):
-        return [str, str]
+    def _acumos_type_out(self):
+        """Custom input type for this processing transformer"""
+        from acumos.modeling import List, create_namedtuple
+        # base input for detect is image itself
+        ImageRow = create_namedtuple('ImageRow', [(FaceDetectTransform.COL_IMAGE_MIME, str),
+                                                  (FaceDetectTransform.COL_IMAGE_DATA, bytes)])
+        # represents a collection of flattened image arrays
+        return List[ImageRow]
 
     def score(self, X, y=None):
         return 0
@@ -68,7 +71,7 @@ class RegionTransform(BaseEstimator, ClassifierMixin):
     def predict(self, X, y=None):
         """
         Assumes a numpy array of [[mime_type, binary_string] ... ]
-           where mime_type is an image-specifying mime type and binary_string is the raw image bytes       
+           where mime_type is an image-specifying mime type and binary_string is the raw image bytes
         """
 
         # group by image index first
@@ -79,12 +82,12 @@ class RegionTransform(BaseEstimator, ClassifierMixin):
         dfReturn = None
         image_region_list = RegionTransform.transform_raw_sample(X)
         for image_data in image_region_list:
-            #print(image_data)
+            # print(image_data)
             img = image_data['data']
             for r in image_data['regions']:  # loop through regions
-                x_max = min(r[0]+r[2], img.shape[1])
-                y_max = min(r[1]+r[3], img.shape[0])
-                if self.transform_mode=="pixelate":
+                x_max = min(r[0] + r[2], img.shape[1])
+                y_max = min(r[1] + r[3], img.shape[0])
+                if self.transform_mode == "pixelate":
                     img[r[1]:y_max, r[0]:x_max] = \
                         RegionTransform.pixelate_image(img[r[1]:y_max, r[0]:x_max])
 
@@ -109,7 +112,7 @@ class RegionTransform(BaseEstimator, ClassifierMixin):
 
         for nameG, rowsG in groupImage:
             local_image = {'image': -1, 'data': b"", 'regions': [], 'mime': ''}
-            image_row = rowsG[rowsG[FaceDetectTransform.COL_REGION_IDX]==FaceDetectTransform.VAL_REGION_IMAGE_ID]
+            image_row = rowsG[rowsG[FaceDetectTransform.COL_REGION_IDX] == FaceDetectTransform.VAL_REGION_IMAGE_ID]
             if len(image_row) < 1:  # must have at least one image set
                 print("Error: RegionTransform could not find a valid image reference for image set {:}".format(nameG))
                 continue
@@ -117,7 +120,7 @@ class RegionTransform(BaseEstimator, ClassifierMixin):
                 print("Error: RegionTransform expected image data, but found empty binary string {:}".format(nameG))
                 continue
             image_byte = image_row[FaceDetectTransform.COL_IMAGE_DATA][0]
-            if type(image_byte)==str:
+            if type(image_byte) == str:
                 image_byte = image_byte.encode()
             image_byte = bytearray(base64.b64decode(image_byte))
             file_bytes = np.asarray(image_byte, dtype=np.uint8)
@@ -127,7 +130,7 @@ class RegionTransform(BaseEstimator, ClassifierMixin):
 
             # now proceed to loop around regions detected
             for index, row in rowsG.iterrows():
-                if row[FaceDetectTransform.COL_REGION_IDX]!=FaceDetectTransform.VAL_REGION_IMAGE_ID:  # skip bad regions
+                if row[FaceDetectTransform.COL_REGION_IDX] != FaceDetectTransform.VAL_REGION_IMAGE_ID:  # skip bad regions
                     local_image['regions'].append([row[FaceDetectTransform.COL_FACE_X], row[FaceDetectTransform.COL_FACE_Y],
                                                    row[FaceDetectTransform.COL_FACE_W], row[FaceDetectTransform.COL_FACE_H]])
             return_set.append(local_image)
@@ -147,10 +150,8 @@ class RegionTransform(BaseEstimator, ClassifierMixin):
         blockHeight = round(blockSize * ratio)  # so that we cover all image
         for x in range(0, img.shape[0], blockSize):
             for y in range(0, img.shape[1], blockHeight):
-                max_x = min(x+blockSize, img.shape[0])
-                max_y = min(y+blockSize, img.shape[1])
-                fill_color = img[x,y] # img[x:max_x, y:max_y].mean()
+                max_x = min(x + blockSize, img.shape[0])
+                max_y = min(y + blockSize, img.shape[1])
+                fill_color = img[x, y]  # img[x:max_x, y:max_y].mean()
                 img[x:max_x, y:max_y] = fill_color
         return img
-
-# RegionTransform.__module__ = '__main__'
index c157c3b..1130fdb 100644 (file)
--- a/setup.py
+++ b/setup.py
@@ -11,22 +11,22 @@ with open(os.path.join(setup_dir, 'face_privacy_filter', '_version.py')) as file
 
 
 setup(
-    name = globals_dict['MODEL_NAME'],
-    version = __version__,
-    packages = find_packages(),
-    author = "Eric Zavesky",
-    author_email = "ezavesky@research.att.com",
-    description = ("Face detection and privacy filtering models"),
-    long_description = ("Face detection and privacy filtering models"),
-    license = "Apache",
-    package_data={globals_dict['MODEL_NAME']:['data/*']},
+    name=globals_dict['MODEL_NAME'],
+    version=__version__,
+    packages=find_packages(),
+    author="Eric Zavesky",
+    author_email="ezavesky@research.att.com",
+    description=("Face detection and privacy filtering models"),
+    long_description=("Face detection and privacy filtering models"),
+    license="Apache",
+    package_data={globals_dict['MODEL_NAME']: ['data/*']},
     scripts=['bin/run_face-privacy-filter_reference.py'],
     setup_requires=['pytest-runner'],
     entry_points="""
     [console_scripts]
     """,
-    #setup_requires=['pytest-runner'],
-    install_requires=['cognita_client',
+    # setup_requires=['pytest-runner'],
+    install_requires=['acumos',
                       'numpy',
                       'sklearn',
                       'opencv-python',
@@ -34,4 +34,4 @@ setup(
     tests_require=['pytest',
                    'pexpect'],
     include_package_data=True,
-    )
+)
index 8b7f5f0..0d4cdf8 100755 (executable)
@@ -7,24 +7,25 @@ import json
 import time
 import os
 
-from flask import Flask, request, current_app, make_response
+from flask import current_app, make_response
 
 import pandas as pd
-import requests
 
-from cognita_client.wrap.load import load_model
+from acumos.wrapped import load_model
 from face_privacy_filter.transform_detect import FaceDetectTransform
 import base64
 
+
 def generate_image_df(path_image="", bin_stream=b""):
     # munge stream and mimetype into input sample
     if path_image and os.path.exists(path_image):
         bin_stream = open(path_image, 'rb').read()
     bin_stream = base64.b64encode(bin_stream)
-    if type(bin_stream)==bytes:
+    if type(bin_stream) == bytes:
         bin_stream = bin_stream.decode()
     return pd.DataFrame([['image/jpeg', bin_stream]], columns=[FaceDetectTransform.COL_IMAGE_MIME, FaceDetectTransform.COL_IMAGE_DATA])
 
+
 def transform(mime_type, base64_data):
     app = current_app
     time_start = time.clock()
index d20654c..a4f7d17 100644 (file)
@@ -1,14 +1,15 @@
 /**\r
image-classes.js - send frames to an image classification service\r
face-privacy.js - send frames to an face privacy service\r
 \r
  Videos or camera are displayed locally and frames are periodically sent to GPU image-net classifier service (developed by Zhu Liu) via http post.\r
  For webRTC, See: https://gist.github.com/greenido/6238800\r
\r
+\r
  D. Gibbon 6/3/15\r
  D. Gibbon 4/19/17 updated to new getUserMedia api, https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia\r
- D. Gibbon 8/1/17 adapted for Cognita\r
+ D. Gibbon 8/1/17 adapted for system\r
+ E. Zavesky 10/19/17 adapted for video+image\r
  */\r
\r
+\r
 "use strict";\r
 \r
 /**\r