cement-count

.gitignore

+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+*pyc
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/

Dockerfile

+FROM python:3.7
+
+RUN apt-get update
+RUN apt-get install tzdata vim -y
+RUN apt-get update && apt-get install tzdata ffmpeg libsm6 libxext6  -y
+
+RUN pip3 install --upgrade pip
+RUN pip3 install matplotlib>=3.2.2 tensorboard>=2.4.1 numpy>=1.18.5 opencv-python>=4.1.2 Pillow>=7.1.2 PyYAML>=5.3.1 requests>=2.23.0 scipy>=1.4.1 torch>=1.7.0 torchvision>=0.8.1 tqdm>=4.41.0 pandas seaborn expiringdict minio cachetools
+RUN pip3 install Cython paho-mqtt==1.5.0 scikit-learn==0.22.2
+RUN pip3 install pymongo==2.8
+RUN pip3 install imutils
+ADD . /app
+#ADD Arial.ttf /root/.config/Ultralytics/
+WORKDIR /app
+CMD ["python3","app.py"]

Dockerfile.bkp

+FROM azracrilensai.azurecr.io/repository/ilens-ai/ilens-openvino-base:v1
+#RUN apt-get update
+RUN apt-get install -y libsm6 libxext6 libxrender-dev
+RUN apt-get install tzdata
+RUN pip3 install --upgrade pip
+RUN pip3 install minio cachetools
+RUN pip3 install yolov5processor==0.0.3
+RUN pip3 install expiringdict
+RUN pip3 install torch==1.6.0
+RUN pip3 install torchvision==0.7.0
+RUN pip3 install numpy~=1.18.5
+RUN pip3 install pymongo~=3.10.1
+RUN pip3 install opencv-python~=4.2.0.34
+#RUN pip3 apt update && 
+
+
+ADD . /app
+
+WORKDIR /app
+CMD ["bash","app.sh"]

README.md

-# Cement Count
-
+# Cement Bag Detection
\ No newline at end of file
-Cement Count
\ No newline at end of file

app.py

+from edge_engine.edge_processor import ExecutePipeline
+from edge_engine.edge_processor import Pubs
+from scripts import CementBagCounter
+from edge_engine.common.config import EDGE_CONFIG
+
+if __name__ == '__main__':
+    pubs = Pubs()
+    mod = CementBagCounter(config=EDGE_CONFIG,
+                           model_config=EDGE_CONFIG["modelConfig"],
+                           pubs=pubs,
+                           device_id=EDGE_CONFIG['deviceId'])
+    ex = ExecutePipeline(mod)
+    ex.run_model()

app.sh

+source /opt/intel/openvino/bin/setupvars.sh
+python3 app.py
\ No newline at end of file

edge_engine/.idea/edge_engine.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="Python 3.7" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file

edge_engine/.idea/inspectionProfiles/profiles_settings.xml

+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>
\ No newline at end of file

edge_engine/.idea/misc.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.7" project-jdk-type="Python SDK" />
+</project>
\ No newline at end of file

edge_engine/.idea/modules.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/edge_engine.iml" filepath="$PROJECT_DIR$/.idea/edge_engine.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file

edge_engine/.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>
\ No newline at end of file

edge_engine/.idea/workspace.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="13900a5d-57a3-4c5f-9fe3-e875b7baffb5" name="Default Changelist" comment="">
+      <change beforePath="$PROJECT_DIR$/.idea/edge_engine.iml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/edge_engine.iml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
+    </list>
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$/.." />
+  </component>
+  <component name="ProjectId" id="1vylO2pvTucEIc7ebybHbpXe1ex" />
+  <component name="ProjectLevelVcsManager" settingsEditedManually="true" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showExcludedFiles" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent">
+    <property name="RunOnceActivity.ShowReadmeOnStart" value="true" />
+    <property name="settings.editor.selected.configurable" value="com.jetbrains.python.configuration.PyActiveSdkModuleConfigurable" />
+  </component>
+  <component name="ServiceViewManager">
+    <option name="viewStates">
+      <list>
+        <serviceView>
+          <treeState>
+            <expand />
+            <select />
+          </treeState>
+        </serviceView>
+      </list>
+    </option>
+  </component>
+  <component name="SvnConfiguration">
+    <configuration />
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="13900a5d-57a3-4c5f-9fe3-e875b7baffb5" name="Default Changelist" comment="" />
+      <created>1627542175766</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1627542175766</updated>
+    </task>
+    <servers />
+  </component>
+  <component name="WindowStateProjectService">
+    <state x="2061" y="163" key="SettingsEditor" timestamp="1627566036512">
+      <screen x="1600" y="0" width="1920" height="1040" />
+    </state>
+    <state x="2061" y="163" key="SettingsEditor/0.0.1600.860/1600.0.1920.1040@1600.0.1920.1040" timestamp="1627566036512" />
+    <state x="2256" y="345" key="com.intellij.ide.util.TipDialog" timestamp="1627565995337">
+      <screen x="1600" y="0" width="1920" height="1040" />
+    </state>
+    <state x="2256" y="345" key="com.intellij.ide.util.TipDialog/0.0.1600.860/1600.0.1920.1040@1600.0.1920.1040" timestamp="1627565995337" />
+    <state x="2256" y="345" key="com.intellij.ide.util.TipDialog/0.42.1600.818/1600.0.1920.1040@1600.0.1920.1040" timestamp="1627542183386" />
+  </component>
+</project>
\ No newline at end of file

edge_engine/ai/model/__init__.py

+from edge_engine.ai.model.modelwraper import ModelWrapper

edge_engine/ai/model/modelwraper.py

+from abc import ABC, abstractmethod
+
+
+class ModelWrapper(ABC):
+    def __init__(self, path=None):
+        """Implement code to load mask_model here"""
+        pass
+
+    def _pre_process(self, x):
+        """Implement code to process raw input into format required for mask_model inference here"""
+        return x
+
+    def _post_process(self, x):
+        """Implement any code to post-process mask_model inference response here"""
+        return x
+
+    @abstractmethod
+    def _predict(self, x):
+        """Implement core mask_model inference code here"""
+        pass
+
+    def predict(self, x):
+        pre_x = self._pre_process(x)
+        prediction = self._predict(pre_x)
+        result = self._post_process(prediction)
+        return result

edge_engine/ai/preprocess/__init__.py

+
+
+

edge_engine/ai/preprocess/gammapreprocessor.py

+# import the necessary packages
+import cv2
+import numpy as np
+
+
+class GammaPreprocessor:
+    def __init__(self, gamma=1.0):
+        # creating Gamma table
+        self.invGamma = 1.0 / gamma
+        self.table = np.array([((i / 255.0) ** self.invGamma) * 255
+                          for i in np.arange(0, 256)]).astype("uint8")
+
+    def preprocess(self, image):
+        return cv2.LUT(image, self.table)

edge_engine/ai/preprocess/imagetoarraypreprocessor.py

+# import the necessary packages
+from keras.preprocessing.image import img_to_array
+
+
+class ImageToArrayPreprocessor:
+    def __init__(self, dataFormat=None):
+        # store the image data format
+        self.dataFormat = dataFormat
+
+    def preprocess(self, image):
+        # apply the Keras utility function that correctly rearranges
+        # the dimensions of the image
+        return img_to_array(image, data_format=self.dataFormat)

edge_engine/ai/preprocess/simplehistogramprocessor.py

+# import the necessary packages
+import cv2
+
+
+class SimpleHistogramPreprocessor:
+    def __init__(self):
+        pass
+
+    def preprocess(self, image):
+        # Run Histogram simple Equalization
+        return cv2.equalizeHist(image)

edge_engine/ai/preprocess/simplepreprocessor.py

+# import the necessary packages
+import cv2
+
+
+class SimplePreprocessor:
+    def __init__(self, width, height, inter=cv2.INTER_AREA):
+        # store the target image width, height, and interpolation
+        # method used when resizing
+        self.width = width
+        self.height = height
+        self.inter = inter
+
+    def preprocess(self, image):
+        # resize the image to a fixed size, ignoring the aspect
+        # ratio
+        return cv2.resize(image, (self.width, self.height),
+                          interpolation=self.inter)

edge_engine/common/config.py

+import os
+import sys
+from edge_engine.common.constants import LicenseModule
+from dateutil import parser
+from datetime import datetime
+from pymongo import MongoClient
+from copy import deepcopy
+import json
+
+
+def licence_validator(payload):
+    try:
+        dt = parser.parse(payload['valid_till'])
+        now = datetime.now()
+        if (now > dt):
+            sys.stdout.write("Licence Expired \n".format())
+            sys.stdout.flush()
+            return False
+        return True
+    except KeyError as e:
+        sys.stderr.write("Error loading licence")
+        return False
+
+
+def get_config_from_mongo(mongo_uri, dbname, basecollection,
+                          key, value):
+    mongo = MongoClient(mongo_uri)
+
+    db = mongo[dbname]
+    config = db[basecollection].find_one({key: value}, {"_id": False})
+    return config
+
+
+def load_conf(config, mongo_uri, dbname):
+    mongo = MongoClient(mongo_uri)
+    db = mongo[dbname]
+    pub_configs = []
+
+    for conf in config['pubConfigs']:
+        if conf["type"].lower() in ["mqtt", "mongo", ]:
+            key = conf["key"]
+            value = conf["value"]
+            collection = conf["conectionCollection"]
+            pub_conf = db[collection].find_one({key: value}, {"_id": False})
+            pub_conf.update(conf)
+            pub_configs.append(pub_conf)
+        else:
+            pub_configs.append(conf)
+
+    config['pubConfigs'] = pub_configs
+
+    return config
+
+
+# """
+# {
+# "MONGO_URI": "mongodb://192.168.3.220:21017",
+# "MONGO_DATABASE": "ilens_thermal_app",
+# "MONGO_COLLECTION": "janus_deployment_details",
+# "MONGO_KEY": "deploymentId",
+# "MONGO_VALUE": "ddd"
+# }
+# """
+
+LOG_LEVEL = os.environ.get("LOG_LEVEL", default="INFO").upper()
+LOG_HANDLER_NAME = os.environ.get("LOG_HANDLER_NAME", default="ilens-edge_engine")
+
+BASE_LOG_PATH = os.environ.get('BASE_LOG_PATH',
+                               default=os.path.join(os.getcwd(), "logs".format()))
+
+if not os.path.isdir(BASE_LOG_PATH):
+    os.mkdir(BASE_LOG_PATH)
+
+CONFIG_ENV = json.loads(os.environ.get('config', default=None))
+sys.stdout.write("config->{} \n".format(json.dumps(CONFIG_ENV)))
+MONGO_URI = CONFIG_ENV.get('MONGO_URI', None)
+MONGO_DATABASE = CONFIG_ENV.get('MONGO_DATABASE', None)
+MONGO_COLLECTION = CONFIG_ENV.get('MONGO_COLLECTION', None)
+MONGO_KEY = CONFIG_ENV.get('MONGO_KEY', None)
+MONGO_VALUE = CONFIG_ENV.get('MONGO_VALUE', None)
+
+if MONGO_URI == None \
+        or MONGO_DATABASE is None \
+        or MONGO_COLLECTION is None \
+        or MONGO_KEY is None \
+        or MONGO_VALUE is None:
+    sys.stderr.write("invalid mongo config  \n")
+    sys.exit(1)
+state = os.environ.get('state',default='prod')
+if state == 'dev':
+    with open('Edge_Config.json') as f:
+        EDGE_CONFIG = json.load(f)
+else:
+    EDGE_CONFIG = get_config_from_mongo(
+        mongo_uri=MONGO_URI,
+        dbname=MONGO_DATABASE, basecollection=MONGO_COLLECTION,
+        key=MONGO_KEY, value=MONGO_VALUE
+    )
+DEVICE_ID = EDGE_CONFIG["deviceId"]
+if EDGE_CONFIG is None:
+    sys.stderr.write("invalid EDGE_CONFIG config  \n")
+    sys.exit(1)
+
+EDGE_CONFIG = load_conf(EDGE_CONFIG, mongo_uri=MONGO_URI,
+                        dbname=MONGO_DATABASE)
+DATA_PATH = EDGE_CONFIG["inputConf"].get('dataPath', os.path.join(os.getcwd(), "data".format()))
+
+sys.stderr.write("Loading data from {} \n".format(DATA_PATH))

edge_engine/common/config1.py

+import os
+import sys
+import configparser
+import json
+from scripts.common.constants import LicenseModule
+import base64
+import jwt
+from dateutil import parser
+from datetime import datetime
+import yaml
+from copy import deepcopy
+
+
+def licence_validator(payload):
+    try:
+        dt = parser.parse(payload['valid_till'])
+        now = datetime.now()
+        if (now > dt):
+            sys.stdout.write("Licence Expired \n".format())
+            sys.stdout.flush()
+            return False
+        return True
+    except KeyError as e:
+        sys.stderr.write("Error loading licence")
+        return False
+
+
+CONFIGURATION_FILE = os.environ.get("CONF_PATH", os.path.join(os.getcwd(), "conf{0}settings.conf".format(os.sep)))
+sys.stdout.write("Reading Config from  {} \n".format(CONFIGURATION_FILE))
+sys.stdout.flush()
+__config = configparser.ConfigParser()
+__config.read(CONFIGURATION_FILE)
+
+LOG_LEVEL = os.environ.get("LOG_LEVEL", __config.get('LOGGER', 'loglevel', fallback="DEBUG")).upper()
+LOG_HANDLER_NAME = os.environ.get("LOG_HANDLER_NAME", __config.get('LOGGER', 'loglevel', fallback="face-id"))
+
+BASE_LOG_PATH = os.environ.get('BASE_LOG_PATH',
+                               __config.get('LOGGER', 'basepath', fallback=os.path.join(os.getcwd(), "logs".format())))
+
+if not os.path.isdir(BASE_LOG_PATH):
+    os.mkdir(BASE_LOG_PATH)
+
+
+
+sys.stdout.write("Data base path  {} \n".format(DATA_PATH))
+
+DEVICE_ID = os.environ.get("DEVICE_ID", __config.get('CLIENT-CONFIG', 'deviceid', fallback="<undefined>"))
+
+LICENCE_FILE = os.environ.get("LICENCE_FILE", __config.get('CLIENT-CONFIG', 'licence-life', fallback="license.lic"))
+LICENCE_FILE = os.path.join(DATA_PATH, LICENCE_FILE)
+
+MODEL_CONFIG_FILE = os.environ.get("MODEL_CONFIG_FILE",
+                                   __config.get('CLIENT-CONFIG', 'mask_model=config-path', fallback="mask_model-config.yaml"))
+MODEL_CONFIG_FILE = os.path.join(DATA_PATH, MODEL_CONFIG_FILE)
+
+with open(MODEL_CONFIG_FILE, 'r') as stream:
+    try:
+        MODEL_CONFIG = yaml.safe_load(stream)
+    except yaml.YAMLError as exc:
+        sys.stderr.write(" **Error loading mask_model config ** \n")
+        sys.stderr.flush()
+        #sys.exit(1)
+
+PUBLISHERS = os.environ.get("PUBLISHERS", __config.get('CLIENT-CONFIG', 'publishers', fallback="")).split(",")
+SUBSCRIBER = os.environ.get("SUBSCRIBER", __config.get('CLIENT-CONFIG', 'subscriber', fallback=""))
+if len(PUBLISHERS) == 0:
+    sys.stdout.write("Empty publishers \n")
+CLIENT_ID = os.environ.get("CLIENT_ID", __config.get('CLIENT-CONFIG', 'client-id', fallback="test-client1"))
+
+STREAM_TYPE = os.environ.get("STREAM_TYPE", __config.get('STREAM-CONFIG', 'stream-type', fallback="usbcam"))
+
+MQTT_CONFIG = {"broker": "", "port": "", "topic": "", "clientId": ""}
+MQTT_SUB_CONFIG = deepcopy(MQTT_CONFIG)
+FRAME_WRITE_CONFIG = {"basepath": None, "filenameFormat": "{deviceId}_{frameId}", "format": "jpg"}
+VIDEO_WRITE_CONFIG = {"basepath": None, "format": "mp4"}
+MONGO_WRITE_CONFIG = {"host": None, "port": 27017, "authSource": None, "collection": None, "dbname": None,
+                      "keys": "frameId,deviceId,timestamp,metric"}
+
+PUBLISHER_CONFIGS = []
+for pub in PUBLISHERS:
+    type, Section = pub.split(":")
+    if type == "MQTT":
+        conf = deepcopy(MQTT_CONFIG)
+        conf["broker"] = os.environ.get("{}_broker".format(Section), __config.get(Section, 'broker'))
+        conf["port"] = int(os.environ.get("{}_port".format(Section), __config.get(Section, 'port')))
+        conf["topic"] = os.environ.get("{}_topic".format(Section), __config.get(Section, 'topic'))
+        conf["clientId"] = os.environ.get("{}_clientid".format(Section),
+                                          __config.get(Section, 'clientid', fallback="ghf-test-00"))
+        conf["type"] = type
+        PUBLISHER_CONFIGS.append(conf)
+    elif type == "FRAMEWRITE":
+        conf = deepcopy(FRAME_WRITE_CONFIG)
+        conf["basepath"] = os.environ.get("{}_basepath".format(Section),
+                                          __config.get(Section, 'basepath', fallback=os.path.normpath(
+                                              os.getcwd() + '{sep}out{sep}frames'.format(sep=os.sep))))
+        conf["iformat"] = os.environ.get("{}_iformat".format(Section), __config.get(Section, 'iformat', fallback="jpg"))
+        conf["filenameFormat"] = os.environ.get("{}_file_name_format".format(Section),
+                                                __config.get(Section, 'file_name_format',
+                                                             fallback="{deviceId}_{frameId}"))
+        if not os.path.isdir(conf["basepath"]):
+            sys.stdout.write("Creating {}  \n".format(conf["basepath"]))
+            os.mkdir(conf["basepath"])
+        conf["type"] = type
+        PUBLISHER_CONFIGS.append(conf)
+    elif type == "VIDEOWRITE":
+        conf = deepcopy(VIDEO_WRITE_CONFIG)
+        conf["basepath"] = os.environ.get("{}_basepath".format(Section),
+                                          __config.get(Section, 'basepath', fallback=os.path.normpath(
+                                              os.getcwd() + '{sep}out{sep}videos'.format(sep=os.sep))))
+        # conf["format"] = os.environ.get("{}_format".format(Section),__config.get(Section, 'file_name_format',fallback="mp4"))
+        conf["filenameFormat"] = os.environ.get("{}_file_name_format".format(Section),
+                                                __config.get(Section, 'file_name_format',
+                                                             fallback="{deviceId}_{timestamp}"))
+        conf["fps"] = int(os.environ.get("{}_fps".format(Section),
+                                         __config.get(Section, 'fps',
+                                                      fallback=30)))
+        conf["dims"] = tuple(os.environ.get("{}_dims".format(Section),
+                                            __config.get(Section, 'dims',
+                                                         fallback="620,320")).split(","))
+        if not os.path.isdir(conf["basepath"]):
+            sys.stdout.write("Creating {}  \n".format(conf["basepath"]))
+            os.mkdir(conf["basepath"])
+        conf["type"] = type
+        PUBLISHER_CONFIGS.append(conf)
+    elif type == "MONGO":
+        conf = deepcopy(MONGO_WRITE_CONFIG)
+        conf["host"] = os.environ.get("{}_host".format(Section),
+                                      __config.get(Section, 'host', fallback="localhost"))
+        conf["port"] = int(os.environ.get("{}_port".format(Section),
+                                          __config.get(Section, 'port', fallback="test")))
+        conf["dbname"] = os.environ.get("{}_dbname".format(Section),
+                                        __config.get(Section, 'dbname', fallback="test"))
+        conf["collection"] = os.environ.get("{}_collection".format(Section),
+                                            __config.get(Section, 'collection', fallback="test"))
+        conf["authSource"] = os.environ.get("{}_authsource".format(Section),
+                                            __config.get(Section, 'authsource', fallback=None))
+        conf["username"] = os.environ.get("{}_username".format(Section),
+                                          __config.get(Section, 'username', fallback=None))
+        conf["password"] = os.environ.get("{}_password".format(Section),
+                                          __config.get(Section, 'password', fallback=None))
+        if len(conf["authSource"]) == 0:
+            conf["authSource"] = None
+        conf["keys"] = os.environ.get("{}_keys".format(Section),
+                                      __config.get(Section, 'keys',
+                                                   fallback="frameId,deviceId,timestamp,metric")).split(",")
+        conf["type"] = type
+        PUBLISHER_CONFIGS.append(conf)
+    else:
+        sys.stderr.write("Unsupported  publisher  {} \n".format(type))
+
+if STREAM_TYPE  in ["rtsp", "usbcam"]:
+    FRAME_WIDTH = os.environ.get("FRAME_WIDTH", __config.get('STREAM-CONFIG', 'width', fallback=480))
+    FRAME_HEIGHT = os.environ.get("FRAME_HEIGHT", __config.get('STREAM-CONFIG', 'height', fallback=640))
+    LATENCY = os.environ.get("LATENCY", __config.get('STREAM-CONFIG', 'latency', fallback=0))
+    FRAME_RATE = os.environ.get("FRAME_RATE", __config.get('STREAM-CONFIG', 'framerate', fallback="30/1"))
+    F_FORMAT = os.environ.get("F_FORMAT", __config.get('STREAM-CONFIG', 'fformat', fallback="BGRx"))
+    USE_GSTREAMER = int(os.environ.get("USE_GSTREAMER", __config.get('STREAM-CONFIG', 'use-gstreamer', fallback=1)))
+    CUSTOM_PIPELINE = os.environ.get("CUSTOM_PIPELINE", __config.get('STREAM-CONFIG', 'custom-pipeline', fallback=None))
+    URI = os.environ.get("URI", __config.get('STREAM-CONFIG', 'uri', fallback=0))
+
+    BUILD_CONFIG = {
+        "sourceType": STREAM_TYPE,
+        "width": FRAME_WIDTH,
+        "height": FRAME_HEIGHT,
+        "latency": LATENCY,
+        "framerate": FRAME_RATE,
+        "format": F_FORMAT,
+        "gstreamer": USE_GSTREAMER,
+        "uri": URI
+    }
+
+elif STREAM_TYPE == "mqtt":
+    MQTT_SUB_CONFIG["broker"] = os.environ.get("STREAM-CONFIG_broker", __config.get('STREAM-CONFIG', 'broker'))
+    MQTT_SUB_CONFIG["port"] = os.environ.get("STREAM-CONFIG_port", __config.get('STREAM-CONFIG', 'port'))
+    MQTT_SUB_CONFIG["topic"] = os.environ.get("STREAM-CONFIG_topic", __config.get('STREAM-CONFIG', 'topic'))
+    MQTT_SUB_CONFIG["clientId"] = os.environ.get("STREAM-CONFIG_clientid",
+                                                 __config.get('STREAM-CONFIG', 'clientid', fallback="sdrt"))
+    MQTT_SUB_CONFIG["sourceType"] = STREAM_TYPE
+    BUILD_CONFIG = MQTT_SUB_CONFIG
+elif STREAM_TYPE == "videofile":
+    BUILD_CONFIG = {"uri": os.environ.get("URI", __config.get('STREAM-CONFIG', 'uri', fallback=0)),
+                    "queueSize": os.environ.get("QUEUE_SIZE",
+                                                __config.get('STREAM-CONFIG', 'queue_size', fallback=128)),
+                    "sourceType": STREAM_TYPE}
+else:
+    raise ValueError("unsupported source  {}".format(STREAM_TYPE))
+
+sys.stdout.write("Loading Licence   {} \n".format(LICENCE_FILE))
+try:
+    private_key = LicenseModule.private_key
+    encoding_algorithm = LicenseModule.encoding_algorithm
+    LICENCE_PAYLOAD = jwt.decode(bytes(base64.b64decode(open(LICENCE_FILE, 'rb').read())), private_key,
+                                 algorithms=[encoding_algorithm])
+except Exception as e:
+    sys.stderr.write("{}".format(e))
+    sys.stderr.write(" **Error loading licence** \n")
+    sys.stderr.flush()
+    #sys.exit(1)

edge_engine/common/constants.py

+
+class LicenseModule:
+    private_key = "3139343831323738414d47454e3936363538373136"
+    encoding_algorithm = "HS256"

edge_engine/common/logsetup.py

+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from edge_engine.common.config import LOG_LEVEL, LOG_HANDLER_NAME, BASE_LOG_PATH
+import logging
+from logging.handlers import RotatingFileHandler
+from logging import WARNING,INFO,DEBUG,ERROR
+import os
+
+DEFAULT_FORMAT = '%(asctime)s %(levelname)5s %(name)s %(message)s'
+DEBUG_FORMAT = '%(asctime)s %(levelname)5s %(name)s [%(threadName)5s:%(filename)5s:%(funcName)5s():%(lineno)s] %(message)s'
+
+EXTRA = {}
+
+FORMATTER = DEFAULT_FORMAT
+if LOG_LEVEL.strip() == "DEBUG":
+    FORMATTER = DEBUG_FORMAT
+
+
+def get_logger(log_handler_name, extra=EXTRA):
+    """
+    Purpose : To create logger .
+    :param log_handler_name: Name of the log handler.
+    :param extra: extra args for the logger
+    :return: logger object.
+    """
+    log_path = os.path.join(BASE_LOG_PATH, log_handler_name + ".log")
+    logstash_temp = os.path.join(BASE_LOG_PATH, log_handler_name + ".db")
+    logger = logging.getLogger(log_handler_name)
+    logger.setLevel(LOG_LEVEL.strip().upper())
+    log_handler = logging.StreamHandler()
+    log_handler.setLevel(LOG_LEVEL)
+    formatter = logging.Formatter(FORMATTER)
+    log_handler.setFormatter(formatter)
+    handler = RotatingFileHandler(log_path, maxBytes=10485760,
+                                  backupCount=5)
+    handler.setFormatter(formatter)
+    logger.addHandler(log_handler)
+    logger.addHandler(handler)
+
+    logger = logging.LoggerAdapter(logger, extra)
+    return logger
+
+
+logger = get_logger(LOG_HANDLER_NAME)
+

edge_engine/common/minio_server.py

+import os, time
+from minio import Minio
+from minio.error import S3Error as ResponseError
+from edge_engine.common.logsetup import logger
+
+
+class MinioClient:
+    def __init__(self ,SECRET_KEY, ACCESS_KEY, BUCKET_NAME, LOCAL_DATA_PATH, MINIO_IP):
+        logger.info("Initalizing minioclient !!")
+        self.SECRET_KEY = SECRET_KEY
+        self.ACCESS_KEY = ACCESS_KEY
+        self.BUCKET_NAME = BUCKET_NAME
+        self.LOCAL_DATA_PATH = LOCAL_DATA_PATH
+        self.MINIO_IP = MINIO_IP
+        self.logfile = "./logs/videowrite.log"
+        self.minioClient = self.connect_to_minio()
+        self.create_bucket(self.BUCKET_NAME)
+
+    def connect_to_minio(self):
+            if self.SECRET_KEY is not None and self.ACCESS_KEY is not None:
+                logger.info("Connecting to Minio Service... !!! ")
+                minio_client = Minio(self.MINIO_IP, access_key = self.ACCESS_KEY, secret_key = self.SECRET_KEY,
+                                    region='us-east-1', secure=False)
+                return minio_client
+            else:
+                logger.info('Access Key and Secret Key String cannot be null')
+                raise Exception('Access Key and Secret Key String cannot be null')
+
+
+    def create_bucket(self, bucket_name):
+        try:
+            if bucket_name not in self.list_buckets():
+                logger.info("Creating bucket {}...".format(bucket_name))
+                self.minioClient.make_bucket(bucket_name, location="us-east-1")
+            else:
+                logger.info("Bucket already exists....")
+        except ResponseError as err:
+            logger.error(err)
+
+    def save_to_bucket(self, bucket_name, data_obj):
+        try:
+            with open(data_obj, 'rb') as file:
+                file_stat = os.stat(data_obj)
+                self.minioClient.put_object(bucket_name, data_obj.split(self.LOCAL_DATA_PATH)[1],
+                                       file, file_stat.st_size)
+        except ResponseError as err:
+            logger.error(err)
+
+    def list_buckets(self):
+        bucketobjects = self.minioClient.list_buckets()
+        bucketlist = []
+        for eachbucket in bucketobjects:
+            bucketlist.append(eachbucket.name)
+        return bucketlist
+
+    def read_write_logs(self):
+        try:
+            f =  open(self.logfile)
+        except Exception as err:
+            print(err)
+            with open(self.logfile, "a") as startfile:
+                startfile.write("")
+            f = open(self.logfile)
+        return [line.split('\n')[0] for line in f]
+
+    def write_write_logs(self, log_str):
+        with open(self.logfile, "a") as my_file:
+            my_file.write(log_str + "\n")
+
+    def upload(self):
+        if self.LOCAL_DATA_PATH[-1]!='/':
+            self.LOCAL_DATA_PATH = self.LOCAL_DATA_PATH+"/"
+        while True:
+            listoffiles = [os.path.join(path, name) for path, subdirs, files in os.walk(self.LOCAL_DATA_PATH) for name in files]
+            listofwrittenfiles = self.read_write_logs()
+            listofnewfiles = list(set(listoffiles) - set(listofwrittenfiles))
+            for fileName in listofnewfiles:
+                try:
+                    logger.info("Uploading {}..".format(fileName.split(self.LOCAL_DATA_PATH)[1]))
+                    self.save_to_bucket(self.BUCKET_NAME, fileName)
+                    self.write_write_logs(fileName)
+                except Exception as e:
+                    logger.error(e)
+            time.sleep(5)
+
+# if __name__=='__main__':
+#     SECRET_KEY = 'minioadmin'
+#     ACCESS_KEY = 'minioadmin'
+#     BUCKET_NAME = 'videobucket'
+#     MINIO_IP = '192.168.3.220:29000'
+#     LOCAL_DATA_PATH = "F:/GDrive Data/Downloads"
+#     obj = MinioClient(SECRET_KEY, ACCESS_KEY, BUCKET_NAME, LOCAL_DATA_PATH, MINIO_IP)
+#     obj.upload()

edge_engine/edge_processor.py

+from edge_engine.common.logsetup import logger
+from edge_engine.common.config import EDGE_CONFIG
+from edge_engine.streamio.datastream import MQTT
+from edge_engine.streamio.datastream import VideoOutputStream
+from edge_engine.streamio.datastream import FrameOutputStream
+from edge_engine.streamio.datastream import FFMPEGOutputStream, OPENCVOutputStream
+from edge_engine.streamio.datastream import MongoDataStreamOut
+from edge_engine.streamio.videostream import ThreadedVideoStream
+from edge_engine.streamio.videostream import FileVideoStream
+from edge_engine.streamio.datastream import DummyPublisher
+from edge_engine.streamio.frameProcessor import FrameProcessor
+from edge_engine.common.minio_server import MinioClient
+import json
+from threading import Thread
+import os
+
+
+class Pubs():
+
+    def __init__(self):
+        self.mqtt_pub = DummyPublisher(name="MQTT")
+        self.frame_write = DummyPublisher(name="FRAME")
+        self.video_write = DummyPublisher(name="VIDEO")
+        self.mongo_write = DummyPublisher(name="MONGO")
+        self.rtp_write = DummyPublisher(name="RTP")
+        self.build_pubs()
+        if 'minioConfig' in EDGE_CONFIG.keys() and \
+                isinstance(EDGE_CONFIG["minioConfig"], dict):
+            self.minio_thread = self.start_minio(EDGE_CONFIG["minioConfig"])
+
+    @staticmethod
+    def start_minio(minio_conf):
+        obj = MinioClient(minio_conf['secretKey'], minio_conf['accessKey'],
+                          minio_conf['bucketName'], minio_conf['localDataPath'],
+                          minio_conf['ip'])
+        t = Thread(target=obj.upload)
+        t.start()
+        return t
+
+    def build_pubs(self):
+        logger.info("building publishers ")
+        state = os.environ.get('state', 'prod')
+        for conf in EDGE_CONFIG["pubConfigs"]:
+            if conf["type"].upper() == "MQTT":
+                self.mqtt_pub = MQTT(broker=conf["broker"], topic=conf["topic"], port=conf["port"]
+                                     , publish_hook=json.dumps)
+
+            elif conf["type"].upper() == "FRAMEWRITE":
+                self.frame_write = FrameOutputStream(
+                    basepath=conf["basepath"],
+                    iformat=conf["iformat"],
+                    filenameFormat=conf["filenameFormat"],
+                    publish_hook=None)
+
+            elif conf["type"].upper() == "VIDEOWRITE":
+                self.video_write = VideoOutputStream(basepath=conf["basepath"],
+                                                     dims=conf["dims"],
+                                                     filenameFormat=conf["filenameFormat"],
+                                                     fps=conf["fps"], publish_hook=None)
+
+            elif conf["type"].upper() == "MONGO":
+                self.mongo_write = MongoDataStreamOut(host=conf["host"],
+                                                      port=conf["port"],
+                                                      dbname=conf["dbname"],
+                                                      collection=conf["collection"],
+                                                      keys=conf["keys"],
+                                                      authsource=conf["authSource"],
+                                                      username=conf["username"],
+                                                      password=conf["password"],
+                                                      publish_hook=None)
+            elif conf["type"].upper() == "RTP":
+
+                self.rtp_write = FFMPEGOutputStream(conf["ffmpegCmd"], conf["RTPEndpoint"], publish_hook=None)
+
+            elif conf["type"].upper() == "OPENCV":
+                logger.info('Dev Testing, Video output will be loaded on new window')
+                self.rtp_write = OPENCVOutputStream()
+            else:
+                logger.error("Unsupported publisher {}".format(conf["type"]))
+
+
+class ExecutePipeline:
+    def __init__(self, model):
+        self.model = model
+
+    def run_model(self):
+        if EDGE_CONFIG["inputConf"]["sourceType"].lower() in ["rtsp", "usbcam"]:
+            logger.info("Selected input stream as Direct cv input")
+            self.threadedVideoStream = ThreadedVideoStream(stream_config=EDGE_CONFIG["inputConf"])
+            self.threadedVideoStream.start()
+            self.frameProcessor = FrameProcessor(stream=self.threadedVideoStream,
+                                                 model=self.model)
+        elif EDGE_CONFIG["inputConf"]["sourceType"].lower() == "videofile":
+            self.fileVideoStream = FileVideoStream(stream_config=EDGE_CONFIG["inputConf"])
+            self.fileVideoStream.start()
+            self.frameProcessor = FrameProcessor(stream=self.fileVideoStream, model=self.model)
+        else:
+            raise ValueError("unsupported source  {}".format(EDGE_CONFIG["inputConf"]["sourceType"]))
+
+        self.start_model()
+
+    def start_model(self):
+        self.frameProcessor.run_model()

edge_engine/streamio/__init__.py

+from edge_engine.streamio.frameProcessor import FrameProcessor
+from .datastreamprocessor import DataStreamProcessor

edge_engine/streamio/datastream/__init__.py

+from edge_engine.streamio.datastream.datastreamwrapper import DataStreamWrapper
+from edge_engine.streamio.datastream.mongodatastreamout import MongoDataStreamOut
+from edge_engine.streamio.datastream.frameoutputstream import FrameOutputStream
+from edge_engine.streamio.datastream.videooutputstream import VideoOutputStream
+from edge_engine.streamio.datastream.mqttstream import MQTT
+from edge_engine.streamio.datastream.ffmpegdata_streamout import FFMPEGOutputStream
+from edge_engine.streamio.datastream.dummyouputstreamer import DummyPublisher
+from edge_engine.streamio.datastream.opencvimshowout import OPENCVOutputStream
\ No newline at end of file

edge_engine/streamio/datastream/datastreamwrapper.py

+from abc import ABC, abstractmethod
+
+
+class DataStreamWrapper(ABC):
+    def __init__(self):
+        """Implement code to load mask_model here"""
+        pass
+
+    def publish(self, x):
+        """Implement code to publish"""
+        return x
+
+    def subscribe(self,hook):
+        """Implement code to subscribe"""
+        return None
\ No newline at end of file

edge_engine/streamio/datastream/dummyouputstreamer.py

+from edge_engine.common.logsetup import logger
+from edge_engine.streamio.datastream.datastreamwrapper import DataStreamWrapper
+
+
+class DummyPublisher(DataStreamWrapper):
+    def __init__(self, name):
+        super().__init__()
+        self.name = name
+
+    def publish(self, x):
+        logger.warn(f"{self.name} Publisher is not configured but you are using it !!!!!!!!!")

edge_engine/streamio/datastream/ffmpegdata_streamout.py

+from edge_engine.streamio.datastream.datastreamwrapper import DataStreamWrapper
+import subprocess as sp
+
+
+class FFMPEGOutputStream(DataStreamWrapper):
+
+    def __init__(self, ffmpeg_cmd, rtp_endpoint, publish_hook=None):
+        super().__init__()
+        self.ffmpeg_cmd = ffmpeg_cmd
+        self.rtp_endpoint = rtp_endpoint
+        self.ffmpeg_cmd.append(self.rtp_endpoint[0])
+        self.proc = sp.Popen(self.ffmpeg_cmd, stdin=sp.PIPE, shell=False)
+        self.publish_hook = publish_hook
+
+    def publish(self, x):
+        if self.publish_hook is not None:
+            x = self.publish_hook(x)
+        frame = x["frame"]
+        self.proc.stdin.write(frame.tostring())
+        self.proc.stdin.flush()

edge_engine/streamio/datastream/frameoutputstream.py

+from edge_engine.streamio.datastream.datastreamwrapper import DataStreamWrapper
+import cv2
+import base64
+import numpy as np
+import os
+from edge_engine.common.logsetup import logger
+from datetime import datetime
+
+
+class FrameOutputStream(DataStreamWrapper):
+    def __init__(self, basepath, iformat="jpg", filenameFormat="{deviceId}_{frameId}_{timestamp}", publish_hook=None):
+        super().__init__()
+        self.basepath = basepath
+        self.iformat = iformat
+        self.filenameFormat = filenameFormat
+        self.publish_hook = publish_hook
+
+
+    def publish(self, x):
+        if self.publish_hook is not None:
+            x= self.publish_hook(x)
+        frame = x["frame"]
+        frame = base64.b64decode(frame.split("data:image/jpeg;base64,")[1])
+        frame = np.fromstring(frame, np.uint8)
+        frame = cv2.imdecode(frame, cv2.IMREAD_COLOR)
+        path = os.path.join(self.basepath, datetime.now().date().isoformat())
+        if not os.path.isdir(path):
+            logger.info("Creating {}  \n".format(path))
+            os.mkdir(path)
+        cv2.imwrite("{path}.{iformat}".format(path=os.path.join(path, self.filenameFormat.format(**x)),
+                                              iformat=self.iformat), frame)
+        return True
+
+    def subscribe(self, hook):
+        super().subscribe(hook)

edge_engine/streamio/datastream/mongodatastreamout.py

+from edge_engine.streamio.datastream.datastreamwrapper import DataStreamWrapper
+from pymongo import MongoClient
+
+
+class MongoDataStreamOut(DataStreamWrapper):
+
+    def __init__(self, host, port, dbname, collection, keys, authsource,username=None,password=None, publish_hook=None):
+        super().__init__()
+        self.host = host
+        self.port = port
+        self.dbname = dbname
+        self.username = username
+        self.password = password
+        self.collection = collection
+        self.publish_hook = publish_hook
+        self.mongo = MongoClient(host=host,
+                                 port=int(port),username=self.username,password=self.password)
+        self.db = self.mongo[dbname]
+        self.keys = keys
+        self.authsource = authsource
+
+    def subscribe(self, hook=None):
+        pass
+
+    def publish(self, data):
+        if self.publish_hook is not None:
+            data = self.publish_hook(data)
+        fin_dat = {}
+        for k, v in data.items():
+            if k in self.keys:
+                fin_dat[k] = v
+        self.db[self.collection].insert(fin_dat)

edge_engine/streamio/datastream/mqttstream.py

+import paho.mqtt.client as paho
+from edge_engine.streamio.datastream.datastreamwrapper import DataStreamWrapper
+from edge_engine.common.logsetup import logger
+from uuid import uuid4
+import traceback
+class MQTT(DataStreamWrapper):
+    @staticmethod
+    def on_connect(client, userdata, flags, rc):
+        logger.info("Connection returned with result code:" + str(rc))
+
+    @staticmethod
+    def on_disconnect(client, userdata, rc):
+        logger.info("Disconnection returned result:" + str(rc))
+
+    @staticmethod
+    def on_subscribe(client, userdata, mid, granted_qos):
+        logger.debug("Subscribing MQTT {} {} {} {}".format(client, userdata, mid, granted_qos))
+
+    def on_message(self, client, userdata, msg):
+        logger.debug("Received message, topic:" + msg.topic + "payload:" + str(msg.payload))
+        if self.subscribe_hook is not None:
+            self.subscribe_hook(msg.payload.decode())
+
+    def __init__(self, broker, port, topic, qos=2, subscribe_hook=None, publish_hook=None):
+        super().__init__()
+        self.broker = broker
+        self.port = int(port)
+        self.topic = topic
+        self.client_name = "{}".format(uuid4())
+        self.client = paho.Client(self.client_name)
+        self.client.on_connect = self.on_connect
+        self.client.on_disconnect = self.on_disconnect
+        self.client.on_subscribe = self.on_subscribe
+        self.client.on_message = self.on_message
+        self.client.connect(host=self.broker, port=self.port)
+        self.subscribe_hook = subscribe_hook
+        self.publish_hook = publish_hook
+        self.qos = qos
+
+    def subscribe(self, hook=None):
+        if hook is not None:
+            self.subscribe_hook =hook
+        self.client.subscribe((self.topic, self.qos))
+        self.client.loop_forever()
+
+    def publish(self, data):
+        try:
+            if self.publish_hook is not None:
+                data = self.publish_hook(data)
+            self.client.publish(self.topic, data)
+        except Exception as e:
+            logger.error(e)
+            logger.error(traceback.format_exc())

edge_engine/streamio/datastream/opencvimshowout.py

+from edge_engine.streamio.datastream.datastreamwrapper import DataStreamWrapper
+import subprocess as sp
+import cv2
+
+
+class OPENCVOutputStream(DataStreamWrapper):
+
+    def __init__(self):
+        super().__init__()
+
+    def publish(self, x):
+        cv2.imshow('Dev Test', x['frame'])
+        key = cv2.waitKey(1)

edge_engine/streamio/datastream/videooutputstream.py

+from edge_engine.streamio.datastream.datastreamwrapper import DataStreamWrapper
+import cv2
+import base64
+import numpy as np
+import os
+from edge_engine.common.logsetup import logger
+from datetime import datetime
+
+
+class VideoOutputStream(DataStreamWrapper):
+    def __init__(self, basepath, dims, filenameFormat="{deviceId}_{timestamp}", fps=30, publish_hook=None):
+        super().__init__()
+        self.basepath = basepath
+        self.dims = (int(dims[0]),int(dims[1]))
+        self.fps = float(fps)
+        self.filenameFormat = filenameFormat
+        self.publish_hook = publish_hook
+        self.four_cc = cv2.VideoWriter_fourcc(*'mp4v')
+        self.out = None
+
+    def publish(self, x):
+        if self.publish_hook is not None:
+            x = self.publish_hook(x)
+        if len(x["metric"]) > 0:
+            if self.out is None:
+                path = os.path.join(self.basepath, datetime.now().date().isoformat())
+                if not os.path.isdir(path):
+                    logger.info("Creating {}  \n".format(path))
+                    os.mkdir(path)
+                self.out = cv2.VideoWriter("{}.mp4".format(os.path.join(path, self.filenameFormat.format(**x))),
+                                           self.four_cc, self.fps, self.dims)
+            frame = x["frame"]
+            frame = base64.b64decode(frame.split("data:image/jpeg;base64,")[1])
+            frame = np.fromstring(frame, np.uint8)
+            frame = cv2.imdecode(frame, cv2.IMREAD_COLOR)
+            self.out.write(frame)
+        else:
+            if self.out  is not None:
+                self.out.release()
+                self.out = None
+        return True
+
+    def subscribe(self, hook):
+        super().subscribe(hook)

edge_engine/streamio/datastreamprocessor.py

+from edge_engine.common.logsetup import logger
+
+
+class DataStreamProcessor:
+    def __init__(self, model, subsciber, publishers=list()):
+        self.model = model
+        self.subsciber = subsciber
+        self.publishers = publishers
+        logger.info("Setting up frame processor !!")
+
+    def processstream(self, msg):
+        print(msg)
+
+    def run_model(self):
+        self.subsciber.subscribe(hook=self.processstream)

edge_engine/streamio/frameProcessor.py

+from edge_engine.common.logsetup import logger
+from edge_engine.common.config import DEVICE_ID
+from uuid import uuid4
+import traceback
+class FrameProcessor:
+    def __init__(self, stream, model):
+        self.model = model
+        self.stream = stream
+        logger.info("Setting up frame processor !!")
+
+    def run_model(self):
+        while self.stream.stream.isOpened():
+            try:
+                logger.debug("Getting frame mask_model")
+                frame = self.stream.read()
+                logger.debug("Running mask_model")
+                data = {"frame": frame[0], "frameId":frame[1] , "deviceId": "{}".format(DEVICE_ID)}
+                self.model.predict(data)
+                logger.debug("publishing mask_model output")
+            except Exception as e:
+                logger.error(e)
+                logger.error(traceback.format_exc())
\ No newline at end of file

edge_engine/streamio/videostream/__init__.py

+from edge_engine.streamio.videostream.fps import FPS
+from edge_engine.streamio.videostream.nvgstreamer import NVGstreamer
+from edge_engine.streamio.videostream.simplevideostream import SimpleVideoStream
+from edge_engine.streamio.videostream.threadedvideostream import ThreadedVideoStream
+from edge_engine.streamio.videostream.filevideostream import FileVideoStream
\ No newline at end of file

edge_engine/streamio/videostream/filevideostream.py

+# import the necessary packages
+from threading import Thread
+import sys
+import cv2
+import time
+
+# import the Queue class from Python 3
+if sys.version_info >= (3, 0):
+    from queue import Queue
+
+# otherwise, import the Queue class for Python 2.7
+else:
+    from Queue import Queue
+
+
+class FileVideoStream:
+    def __init__(self, stream_config, transform=None):
+        # initialize the file video stream along with the boolean
+        # used to indicate if the thread should be stopped or not
+        self.transform = transform
+        self.stream_config = stream_config
+        # initialize the queue used to store frames read from
+        # the video file
+        self.build_pipeline()
+
+    def start(self):
+        # start a thread to read frames from the file video stream
+        self.thread.start()
+        return self
+
+    def build_cv_obj(self):
+        self.stream = cv2.VideoCapture(self.stream_config["uri"])
+        self.stopped = False
+
+    def build_pipeline(self):
+        self.build_cv_obj()
+        if "queueSize" not in self.stream_config:
+            self.stream_config["queueSize"] = 128
+
+        self.Q = Queue(maxsize=int(self.stream_config["queueSize"]))
+        # intialize thread
+        self.thread = Thread(target=self.update, args=())
+        self.thread.daemon = True
+
+    def is_opened(self):
+        return self.stream.isOpened()
+
+    def update(self):
+        # keep looping infinitely
+        count = 0
+        while True:
+            # if the thread indicator variable is set, stop the
+            # thread
+            if self.stopped:
+                break
+
+            # otherwise, ensure the queue has room in it
+            if not self.Q.full():
+                # read the next frame from the file
+                (grabbed, frame) = self.stream.read()
+
+                # if the `grabbed` boolean is `False`, then we have
+                # reached the end of the video file
+                if grabbed is False or frame is None:
+                    # self.stopped = True
+                    count = 0
+                    self.build_cv_obj()
+                    continue
+
+                # if there are transforms to be done, might as well
+                # do them on producer thread before handing back to
+                # consumer thread. ie. Usually the producer is so far
+                # ahead of consumer that we have time to spare.
+                #
+                # Python is not parallel but the transform operations
+                # are usually OpenCV native so release the GIL.
+                #
+                # Really just trying to avoid spinning up additional
+                # native threads and overheads of additional
+                # producer/consumer queues since this one was generally
+                # idle grabbing frames.
+                if self.transform:
+                    frame = self.transform(frame)
+
+                # add the frame to the queue
+                self.Q.put((frame, count))
+                count = count+1
+            else:
+                time.sleep(0.1)  # Rest for 10ms, we have a full queue
+
+        self.stream.release()
+
+    def read(self):
+        # return next frame in the queue
+        return self.Q.get()
+
+    # Insufficient to have consumer use while(more()) which does
+    # not take into account if the producer has reached end of
+    # file stream.
+    def running(self):
+        return self.more() or not self.stopped
+
+    def more(self):
+        # return True if there are still frames in the queue. If stream is not stopped, try to wait a moment
+        tries = 0
+        while self.Q.qsize() == 0 and not self.stopped and tries < 5:
+            time.sleep(0.1)
+            tries += 1
+
+        return self.Q.qsize() > 0
+
+    def stop(self):
+        # indicate that the thread should be stopped
+        self.stopped = True
+        # wait until stream resources are released (producer thread might be still grabbing frame)
+        self.thread.join()

edge_engine/streamio/videostream/fps.py

+# import the necessary packages
+import datetime
+
+
+class FPS:
+    def __init__(self):
+        # store the start time, end time, and total number of frames
+        # that were examined between the start and end intervals
+        self._start = None
+        self._end = None
+        self._numFrames = 0
+
+    def start(self):
+        # start the timer
+        self._start = datetime.datetime.now()
+        return self
+
+    def stop(self):
+        # stop the timer
+        self._end = datetime.datetime.now()
+
+    def update(self):
+        # increment the total number of frames examined during the
+        # start and end intervals
+        self._numFrames += 1
+
+    def elapsed(self):
+        # return the total number of seconds between the start and
+        # end interval
+        return (self._end - self._start).total_seconds()
+
+    def fps(self):
+        # compute the (approximate) frames per second
+        return self._numFrames / self.elapsed()

edge_engine/streamio/videostream/nvgstreamer.py

+import cv2
+
+
+class NVGstreamer:
+
+    def __init__(self, buildconfig):
+        self.width = 480
+        self.height = 640
+        self.latency = 0
+        self.framerate = "30/1"
+        self.fformat = "BGRx"
+
+        self.BUILD_CONFIG = {
+            "width": self.width,
+            "height": self.height,
+            "latency": self.latency,
+            "framerate": self.framerate,
+            "format": self.fformat,
+            "gstreamer": True
+        }
+
+        self.BUILD_CONFIG.update(buildconfig)
+
+    def open_cam_rtsp(self):
+        gst_str = ('rtspsrc location={uri} latency={latency} ! '
+                   'rtph264depay ! h264parse ! omxh264dec ! '
+                   'nvvidconv ! videorate ! '
+                   'video/x-raw, width=(int){width}, height=(int){height}, '
+                   'format=(string){format}, framerate=(fraction){framerate} ! '
+                   'videoconvert ! appsink').format(**self.BUILD_CONFIG)
+        print(gst_str)
+        return cv2.VideoCapture(gst_str, cv2.CAP_GSTREAMER)
+
+    def open_cam_usb(self):
+        # We want to set width and height here, otherwise we could just do:
+        #     return cv2.VideoCapture(dev)
+        gst_str = ('v4l2src device=/dev/video{uri} ! '
+                   'video/x-raw, width=(int){width}, height=(int){height}, '
+                   'format=(string){format}, framerate=(fraction){framerate} ! '
+                   'videoconvert ! appsink').format(**self.BUILD_CONFIG)
+        print(gst_str)
+        return cv2.VideoCapture(gst_str, cv2.CAP_GSTREAMER)
+
+    def open_cam_onboard(self):
+        # On versions of L4T prior to 28.1, add 'flip-method=2' into gst_str
+        gst_str = ('nvcamerasrc ! '
+                   'video/x-raw(memory:NVMM), '
+                   'width=(int)2592, height=(int)1458, '
+                   'format=(string)I420 ! '
+                   'nvvidconv ! videorate ! '
+                   'video/x-raw, width=(int){width}, height=(int){height}, '
+                   'format=(string){format}, framerate=(fraction){framerate} !'
+                   'videoconvert ! appsink').format(**self.BUILD_CONFIG)
+        print(gst_str)
+        return cv2.VideoCapture(gst_str, cv2.CAP_GSTREAMER)
+
+    def custom_pipeline(self):
+        gst_str = "{customGstPipelineString}".format(**self.BUILD_CONFIG)
+        print(gst_str)
+        return cv2.VideoCapture(gst_str, cv2.CAP_GSTREAMER)
+
+    def build_pipeline(self):
+        if self.BUILD_CONFIG["gStreamer"]!=True:
+            if  self.BUILD_CONFIG["sourceType"] == "usbcam":
+                self.cap = cv2.VideoCapture(int(self.BUILD_CONFIG["uri"]))
+            else:
+                self.cap = cv2.VideoCapture(self.BUILD_CONFIG["uri"])
+        elif self.BUILD_CONFIG["sourceType"] == "rtsp":
+            self.cap = self.open_cam_rtsp()
+        elif self.BUILD_CONFIG["sourceType"] == "usbcam":
+            self.cap = self.open_cam_usb()
+        elif self.BUILD_CONFIG["sourceType"] == "onboard":
+            self.cap = self.open_cam_onboard()
+        elif self.BUILD_CONFIG["sourceType"] == "customPipeline":
+            self.cap = self.custom_pipeline()
+        else:
+            raise ValueError("unimplemented source {}".format(self.BUILD_CONFIG["sourceType"]))
+
+    def get_stream(self):
+        return self.cap

edge_engine/streamio/videostream/simplevideostream.py

+from edge_engine.common.logsetup import logger
+from edge_engine.streamio.videostream import NVGstreamer
+
+
+class SimpleVideoStream:
+    def __init__(self, stream_config, name="SimpleVideoStream"):
+        self.stream_config = stream_config
+        self.build_pipeline()
+        (self.grabbed, self.frame) = self.stream.read()
+        self.name = name
+
+    def build_pipeline(self):
+        self.gstreamer = NVGstreamer(self.stream_config)
+        self.gstreamer.build_pipeline()
+        self.stream = self.gstreamer.get_stream()
+
+    def start(self):
+        logger.info("Starting video stream ")
+        if self.stream.isOpened():
+            self.grabbed, self.frame = self.stream.read()
+            if self.grabbed is False:
+                logger.error("Empty Frame !!!! ")
+                logger.error("Error opening Capture !!!! ")
+                self.build_pipeline()
+            return self
+        else:
+            logger.error("Error opening Capture !!!! ")
+            self.build_pipeline()
+
+    def is_opened(self):
+        return self.stream.isOpened()
+
+    def read(self):
+        # return the frame most recently read
+        if self.stream.isOpened():
+            self.grabbed, self.frame = self.stream.read()
+            if self.grabbed is False:
+                logger.error("Empty Frame !!!! ")
+                raise ValueError("Empty Frame !!!! ")
+            return self.frame
+        else:
+            logger.error("Error opening Capture !!!! ")
+            raise ValueError("Error opening Capture !!!! ")
+
+    def stop(self):
+        if self.stream.isOpened():
+            self.stream.release()

edge_engine/streamio/videostream/threadedvideostream.py

+# import the necessary packages
+from threading import Thread
+import time
+from edge_engine.streamio.videostream import NVGstreamer
+from edge_engine.common.logsetup import logger
+
+
+class ThreadedVideoStream:
+    def __init__(self, stream_config, name="ThreadedVideoStream"):
+        # initialize the video camera stream and read the first frame
+        # from the stream
+        self.stream_config = stream_config
+        self.build_pipeline()
+        # self.stream = stream
+        (self.grabbed, self.frame) = self.stream.read()
+        # initialize the thread name
+        self.name = name
+
+        # initialize the variable used to indicate if the thread should
+        # be stopped
+        self.stopped = False
+
+    def build_pipeline(self):
+        self.gstreamer = NVGstreamer(self.stream_config)
+        self.gstreamer.build_pipeline()
+        self.stream = self.gstreamer.get_stream()
+
+    def start(self):
+        # start the thread to read frames from the video stream
+        t = Thread(target=self.update, name=self.name, args=())
+        t.daemon = True
+        t.start()
+        return self
+
+    def update(self):
+        # keep looping infinitely until the thread is stopped
+        while True:
+            # if the thread indicator variable is set, stop the thread
+            if self.stopped:
+                return
+
+            # otherwise, read the next frame from the stream
+            (self.grabbed, self.frame) = self.stream.read()
+            if self.grabbed is False or self.frame is None:
+                logger.error("Empty Frame !!!! ")
+                logger.error("Error opening Capture !!!! ")
+                self.build_pipeline()
+
+    def read(self):
+        # return the frame most recently read
+        return self.frame
+
+    def stop(self):
+        # indicate that the thread should be stopped
+        self.stopped = True
+        time.sleep(0.2)
+        self.stream.release()

edge_engine/version.py

+# Copyright 2019 KnowledgeLens pvt Ltd.
+
+
+VERSION = '1.0.0.alpha'

infocenter.py

+import traceback
+from datetime import datetime
+from uuid import uuid1
+from scripts.common.config import MONGO_DB_OBJ, APP_MONGO_COLLECTION
+from edge_engine.common.logsetup import logger
+import os
+
+class MongoLogger:
+    def __init__(self):
+        self.camera_key = os.environ.get('app',None)
+        self.attendance_event_collection = MONGO_DB_OBJ[APP_MONGO_COLLECTION.get('eventLogCollection')]
+        self.camera_configuration = MONGO_DB_OBJ[APP_MONGO_COLLECTION.get('cameraConfigurationCollection')]
+        self.camera_mapping_json = self.get_all_cameras()
+
+    def get_all_cameras(self):
+        camera_mapping_json = self.camera_configuration.find({'decommissioned': False}, {"_id": 0})
+        camera_json = {}
+        for each in camera_mapping_json:
+            camera_json[each['cameraId']] = each['cameraName']
+        return camera_json
+
+    def insert_attendance_event_to_mongo(self, data):
+        try:
+            input_data = {
+                "eventId": str(uuid1()).split('-')[0],
+                "cameraId": data['deviceId'],
+                "cameraName": self.camera_mapping_json.get(data['deviceId'], "Thermal Camera"),
+                "timestamp": datetime.now().strftime("%b %d %Y %H:%M:%S"),
+                "frame": data['frame'],
+                "eventtype": "Intrusion Detection",
+                "bg_color": data["bg_color"],
+                "font_color": data["font_color"],
+                "intrusion_message": data["message"],
+                "alert_sound": data["alert_sound"],
+                "logged_activity": data["activity"],
+            "app":self.camera_key}
+
+            logger.info("Pushing to Mongo..")
+            input_data["timestamp"] = datetime.now()
+            self.attendance_event_collection.insert(input_data)
+        except Exception as e:
+            logger.info(e)
+            logger.error(traceback.format_exc())

requirements.txt

+numpy~=1.18.5
+pymongo~=3.10.1
+opencv-python~=4.2.0.34
+cachetools~=4.1.0
+yolov5processor==0.0.3
+expiringdict
\ No newline at end of file

scripts/__init__.py

+from.cement_counter import CementBagCounter
\ No newline at end of file

scripts/cement_counter.py

+import cv2
+import base64
+import datetime
+import traceback
+import numpy as np
+from expiringdict import ExpiringDict
+import time
+from edge_engine.common.logsetup import logger
+from scripts.utils.infocenter import MongoLogger
+#from yolov5processor.infer import ExecuteInference
+from scripts.utils.edge_utils import get_extra_fields
+from edge_engine.ai.model.modelwraper import ModelWrapper
+from scripts.utils.centroidtracker import CentroidTracker
+from scripts.common.constants import JanusDeploymentConstants
+from scripts.utils.image_utils import draw_circles_on_frame, resize_to_64_64
+import json
+
+
+class CementBagCounter(ModelWrapper):
+
+    def __init__(self, config, model_config, pubs, device_id):
+        super().__init__()
+        """
+        init function
+        """
+        self.type = config['inputConf']['sourceType']
+        if config['inputConf']['sourceType'] == 'videofile':
+            f = open('cement_bag.json', "r")
+            self.dets = json.loads(f.read())
+            f.close()
+        self.config = config["config"]
+        self.device_id = device_id
+        self.rtp = pubs.rtp_write
+        self.mongo_logger = MongoLogger()
+        #model = get_extra_fields(self.device_id).get(JanusDeploymentConstants.MODEL_KEY,
+        #                                             "/app/data/yolov5_s_v2.pt")
+        #self.yp = ExecuteInference(weight=model,
+        #                           gpu=model_config.get("gpu", False),
+        #                           agnostic_nms=model_config.get("agnostic_nms", False),
+        #                           iou=model_config.get("iou", 0.5),
+        #                           confidence=model_config.get("confidence", 0.6))
+        self.ct = CentroidTracker(maxDisappeared=model_config.get("ct_frames", 1))
+        self.classes = {0: 'Cement Bag'}
+        self.count = None
+        self.initial_object_position = None
+        self.uncounted_objects = ExpiringDict(max_len=model_config.get("uncounted_obj_length", 50),
+                                              max_age_seconds=model_config.get("uncounted_obj_age", 60))
+        self.frame_skipping = {
+            "to_skip": model_config.get("skip_alternative_frames", False),
+            "skip_current_frame": False,
+            "detection_value": None
+        }
+
+    def _pre_process(self, x):
+        """
+        Do preprocessing here, if any
+        :param x: payload
+        :return: payload
+        """
+        return x
+
+    def _post_process(self, x):
+        """
+        Apply post processing here, if any
+        :param x: payload
+        :return: payload
+        """
+        self.rtp.publish(x)  # video stream
+        return x
+
+    def track_bags(self, dets, im0, centroid_color=(255, 0, 0)):
+        """
+        Track the bags using Centroid based tracking
+        :param dets: prediction output
+        :param im0: raw frame
+        :param centroid_color: color given to the centroid marking
+        :return: centroid points, frame
+        """
+        bags = list()
+        for det in dets:
+            dete = np.array([det['points'][0], det['points'][1], det['points'][2], det['points'][3]])
+            bags.append(dete.astype("int"))
+        objects = self.ct.update(bags)
+        if centroid_color is not False:
+            for (objectID, centroid) in objects.items():
+                cv2.circle(im0, (tuple(centroid)), 4, centroid_color, -1)
+        return objects, im0
+
+    def get_line_coordinates(self):
+        """
+        Get the line coordinates from the deployment JSON
+        """
+        _janus_deployment = get_extra_fields(self.device_id)
+        _coordinates = [_janus_deployment.get(coordinate_key) for coordinate_key in
+                        JanusDeploymentConstants.LINE_COORDINATES]
+        _alignment = _janus_deployment.get(JanusDeploymentConstants.ALIGNMENT_KEY)
+        return _alignment, _coordinates
+
+    def line_point_position(self, point):
+        """
+        Get the position of point w.r.t. the line
+        :param point: point to be compared
+        :return: boolean
+        """
+        _alignment, line_coordinates = self.get_line_coordinates()
+
+        assert len(line_coordinates) == 4, "Line coordinates variable is invalid"
+        assert len(point) == 2, "Point variable is invalid"
+
+        if (line_coordinates[2] - line_coordinates[0]) == 0 and _alignment == "vertical":
+            if point[0] > line_coordinates[2]:
+                return True
+            else:
+                return False
+        else:
+
+            _slope = (line_coordinates[3] - line_coordinates[1]) / (line_coordinates[2] - line_coordinates[0])
+
+        _point_equation_value = point[1] - line_coordinates[1] - _slope * (point[0] - line_coordinates[0])
+        if _point_equation_value > 0:
+            return True
+        else:
+            return False
+
+    def draw_line_over_image(self, frame, color=(255, 0, 0)):
+        """
+        Draws line over the counting line
+        :param frame: frame for
+        :param color:
+        :return:
+        """
+        _alignment, line_coordinates = self.get_line_coordinates()
+        assert len(line_coordinates) == 4, "Line coordinates variable is invalid"
+        return cv2.line(frame, (line_coordinates[0], line_coordinates[1]), (line_coordinates[2], line_coordinates[3]),
+                        color, 3)
+
+    def validate_point_position(self, point):
+        """
+        Validate the position of the point w.r.t. the line
+        :param point: centroid
+        :return: bool
+        """
+        _alignment, line_coordinates = self.get_line_coordinates()
+        assert _alignment in [JanusDeploymentConstants.VERTICAL, JanusDeploymentConstants.HORIZONTAL], \
+            "Invalid alignment variable"
+        if _alignment == JanusDeploymentConstants.VERTICAL:
+            line_y2 = line_coordinates[3]
+            line_y1 = line_coordinates[1]
+            if line_y1 < point[1] < line_y2 or line_y2 < point[1] < line_y1:
+                return True
+            else:
+                return False
+        else:
+            line_x2 = line_coordinates[2]
+            line_x1 = line_coordinates[0]
+            if line_x1 < point[0] < line_x2 or line_x2 < point[0] < line_x1:
+                return True
+            else:
+                return False
+
+    def send_payload(self, frame, label='CementBagDetected', bg_color="#474520", font_color="#FFFF00", alert_sound=None,
+                     message="Cement Bag Detected!"):
+        """
+        Insert event to Mongo
+        :param message:
+        :param frame:
+        :param label:
+        :param bg_color:
+        :param font_color:
+        :param alert_sound:
+        :return: None
+        """
+
+        payload = {"deviceId": self.device_id, "message": message,
+                   "frame": 'data:image/jpeg;base64,' + base64.b64encode(
+                       cv2.imencode('.jpg', frame)[1].tostring()).decode("utf-8"), "activity": label,
+                   "bg_color": bg_color, "font_color": font_color, "alert_sound": alert_sound, "app": "cement"}
+
+        self.mongo_logger.insert_attendance_event_to_mongo(payload)
+
+    def update_bag_count(self, frame, detection_objects):
+        """
+        Maintains the bag counts
+        :param frame: image
+        :param detection_objects: detection object having object id and centroids
+        """
+        for (objectID, centroid) in detection_objects.items():
+            if self.validate_point_position(centroid):
+                if not isinstance(self.count, int):
+                    logger.debug("Initializing the count variable")
+                    # Initializing the bag count
+                    self.count = 0
+
+                if not isinstance(self.initial_object_position, bool):
+                    logger.debug("Initializing the initial object position")
+                    self.initial_object_position = self.line_point_position(point=centroid)
+
+                _point_position = self.line_point_position(point=centroid)
+
+                # Check point in the same side as the initial object
+                if _point_position == self.initial_object_position:
+                    # Check the object is not already counted
+                    if objectID not in self.uncounted_objects:
+                        self.uncounted_objects[objectID] = centroid
+                    frame = draw_circles_on_frame(frame, centroid, radius=10, color=(0, 0, 255), thickness=-1)
+
+                elif objectID in self.uncounted_objects:
+                    self.uncounted_objects.pop(objectID, None)
+                    self.count += 1
+                    frame = draw_circles_on_frame(frame, centroid, radius=10, color=(0, 255, 0), thickness=-1)
+                    self.send_payload(resize_to_64_64(frame=frame))
+                else:
+                    frame = draw_circles_on_frame(frame, centroid, radius=10, color=(0, 255, 0), thickness=-1)
+
+        return frame
+
+    def _predict(self, obj):
+        try:
+            time.sleep(0.05)
+            frame = obj['frame']
+            id = int(obj['frameId'])
+            if self.frame_skipping["to_skip"]:
+                if not self.frame_skipping["skip_current_frame"]:
+                    if self.type == 'videofile':
+                        dets = self.dets[id][str(id)]['detections']
+                    else:
+                        #dets = self.yp.predict(frame)
+                        print("**************")
+                    # dets = self.yp.predict(frame)
+                    self.frame_skipping["detection_value"] = dets
+                    self.frame_skipping["skip_current_frame"] = True
+                else:
+                    dets = self.frame_skipping["detection_value"]
+                    self.frame_skipping["skip_current_frame"] = False
+            else:
+                if self.type == 'videofile':
+                    dets = self.dets[id][str(id)]['detections']
+                else:
+                    #dets = self.yp.predict(frame)
+                    print("******************")
+            objects, frame = self.track_bags(dets, frame)
+            frame = self.update_bag_count(frame=frame, detection_objects=objects)
+            logger.debug("Counts: {}".format(self.count))
+
+            obj['frame'] = cv2.resize(self.draw_line_over_image(frame), (self.config.get('FRAME_WIDTH'), self.config.
+                                                                         get('FRAME_HEIGHT')))
+            timestamp = datetime.datetime.now().replace(microsecond=0).isoformat()
+            obj["timestamp"] = timestamp
+        except Exception as e:
+            logger.exception(f"Error: {e}")
+            obj['frame'] = cv2.resize(obj['frame'], (self.config.get('FRAME_WIDTH'), self.config.get('FRAME_HEIGHT')))
+            logger.exception(traceback.format_exc())
+            obj["error"] = "{}".format(e)
+            obj["message"] = "{}".format("error processing frame")
+            obj["status"] = False
+            obj["timestamp"] = datetime.datetime.now().replace(microsecond=0).isoformat()
+        return obj

scripts/common/config.py

+import os
+import sys
+import json
+
+from pymongo import MongoClient
+
+MAIN_OS_VARIABLE = json.loads(os.environ.get('config'))
+if MAIN_OS_VARIABLE is None:
+	sys.stderr.write("Configuration not found...")
+	sys.stderr.write("Exiting....")
+	sys.exit(1)
+
+MONGO_URI = MAIN_OS_VARIABLE.get('MONGO_URI')
+MONGO_SERVICE_DB = MAIN_OS_VARIABLE.get('MONGO_DB')
+MONGO_SERVICE_COLL = MAIN_OS_VARIABLE.get('MONGO_COLL')
+
+MONGO_DB_OBJ = MongoClient(MONGO_URI)[MONGO_SERVICE_DB]
+
+HOST_CONFIG = MONGO_DB_OBJ[MONGO_SERVICE_COLL].find_one({'configId': 'hostConfig'}).get('config')
+APP_MONGO_COLLECTION = MONGO_DB_OBJ[MONGO_SERVICE_COLL].find_one({'configId': 'appMongoConfig'}).get('config')
+JANUS_CONFIG = MONGO_DB_OBJ[MONGO_SERVICE_COLL].find_one({'configId': 'janusConfig'}).get('config')

scripts/common/constants.py

+class JanusDeploymentConstants:
+	JANUS_DEPLOYMENT_COLLECTION = "janusDeploymentConfigurations"
+	DEPLOYMENT_ID = 'deploymentId'
+	EXTRA_FIELDS_KEY = 'extra_fields'
+	LINE_COORDINATES = ['x1', 'y1', 'x2', 'y2']
+	COUNT_BAGS_FLAG = 'count_bags'
+	ALIGNMENT_KEY = 'alignment'
+	VERTICAL = 'vertical'
+	HORIZONTAL = 'horizontal'
+	MODEL_KEY = 'model'
+
+
+class CameraConstants:
+	videortpmap="VP8/90000"
+	videopt=96
+	threads=3
+	gStreamer = False
+	eventType = 'deploy'
+	created_by = 'user_6501'
+	event_status = 'pending'
+	deploymentTypeCreate = 'upgrade_and_deploy'
+	deploymentTypeRemove = 'remove'
+	pipeline_internal = {}
+	pipeline_category = "ai"
+	thread = 1
+	job_id = "pipeline_129"
+	deployment_key = 'deploymentId'
+	pipeline_deployment_type = 'docker'
+	docker_deployment_type = 'single'
+	command_eventtype = 'command'
+	command_type = 'docker'
+	restart_command = "restart_container"
+	stop_command = "stop_container"
+	start_command = "start_container"
+

scripts/loopbackmodel.py

+from edge_engine.ai.model.modelwraper import ModelWrapper
+import cv2
+import base64
+
+
+class LoopBackModel(ModelWrapper):
+
+    def __init__(self, pubs, path=None, ):
+        super().__init__(path)
+        self.mqtt = pubs.mqtt_pub
+
+    def _pre_process(self, x):
+        return x
+
+    def _post_process(self, x):
+        image = cv2.imencode('.jpg', x['frame'])[1].tostring()
+        image = 'data:image/jpeg;base64,' + base64.b64encode(image).decode("utf-8")
+        x['frame'] = image
+        self.mqtt.publish(x)
+        return x
+
+    def _predict(self, x):
+        return x
+
+    def predict(self, x):
+        return super().predict(x)

scripts/utils/centroidtracker.py

+# import the necessary packages
+from scipy.spatial import distance as dist
+from collections import OrderedDict
+import numpy as np
+
+class CentroidTracker():
+	def __init__(self, maxDisappeared=50):
+		# initialize the next unique object ID along with two ordered
+		# dictionaries used to keep track of mapping a given object
+		# ID to its centroid and number of consecutive frames it has
+		# been marked as "disappeared", respectively
+		self.nextObjectID = 0
+		self.objects = OrderedDict()
+		self.disappeared = OrderedDict()
+
+		# store the number of maximum consecutive frames a given
+		# object is allowed to be marked as "disappeared" until we
+		# need to deregister the object from tracking
+		self.maxDisappeared = maxDisappeared
+
+	def register(self, centroid):
+		# when registering an object we use the next available object
+		# ID to store the centroid
+		self.objects[self.nextObjectID] = centroid
+		self.disappeared[self.nextObjectID] = 0
+		self.nextObjectID += 1
+
+	def deregister(self, objectID):
+		# to deregister an object ID we delete the object ID from
+		# both of our respective dictionaries
+		del self.objects[objectID]
+		del self.disappeared[objectID]
+
+	def update(self, rects):
+		# check to see if the list of input bounding box rectangles
+		# is empty
+		if len(rects) == 0:
+			# loop over any existing tracked objects and mark them
+			# as disappeared
+			for objectID in list(self.disappeared.keys()):
+				self.disappeared[objectID] += 1
+
+				# if we have reached a maximum number of consecutive
+				# frames where a given object has been marked as
+				# missing, deregister it
+				if self.disappeared[objectID] > self.maxDisappeared:
+					self.deregister(objectID)
+
+			# return early as there are no centroids or tracking info
+			# to update
+			return self.objects
+
+		# initialize an array of input centroids for the current frame
+		inputCentroids = np.zeros((len(rects), 2), dtype="int")
+
+		# loop over the bounding box rectangles
+		for (i, (startX, startY, endX, endY)) in enumerate(rects):
+			# use the bounding box coordinates to derive the centroid
+			cX = int((startX + endX) / 2.0)
+			cY = int((startY + endY) / 2.0)
+			inputCentroids[i] = (cX, cY)
+
+		# if we are currently not tracking any objects take the input
+		# centroids and register each of them
+		if len(self.objects) == 0:
+			for i in range(0, len(inputCentroids)):
+				self.register(inputCentroids[i])
+
+		# otherwise, are are currently tracking objects so we need to
+		# try to match the input centroids to existing object
+		# centroids
+		else:
+			# grab the set of object IDs and corresponding centroids
+			objectIDs = list(self.objects.keys())
+			objectCentroids = list(self.objects.values())
+
+			# compute the distance between each pair of object
+			# centroids and input centroids, respectively -- our
+			# goal will be to match an input centroid to an existing
+			# object centroid
+			D = dist.cdist(np.array(objectCentroids), inputCentroids)
+
+			# in order to perform this matching we must (1) find the
+			# smallest value in each row and then (2) sort the row
+			# indexes based on their minimum values so that the row
+			# with the smallest value as at the *front* of the index
+			# list
+			rows = D.min(axis=1).argsort()
+
+			# next, we perform a similar process on the columns by
+			# finding the smallest value in each column and then
+			# sorting using the previously computed row index list
+			cols = D.argmin(axis=1)[rows]
+
+			# in order to determine if we need to update, register,
+			# or deregister an object we need to keep track of which
+			# of the rows and column indexes we have already examined
+			usedRows = set()
+			usedCols = set()
+
+			# loop over the combination of the (row, column) index
+			# tuples
+			for (row, col) in zip(rows, cols):
+				# if we have already examined either the row or
+				# column value before, ignore it
+				# val
+				if row in usedRows or col in usedCols:
+					continue
+
+				# otherwise, grab the object ID for the current row,
+				# set its new centroid, and reset the disappeared
+				# counter
+				objectID = objectIDs[row]
+				self.objects[objectID] = inputCentroids[col]
+				self.disappeared[objectID] = 0
+
+				# indicate that we have examined each of the row and
+				# column indexes, respectively
+				usedRows.add(row)
+				usedCols.add(col)
+
+			# compute both the row and column index we have NOT yet
+			# examined
+			unusedRows = set(range(0, D.shape[0])).difference(usedRows)
+			unusedCols = set(range(0, D.shape[1])).difference(usedCols)
+
+			# in the event that the number of object centroids is
+			# equal or greater than the number of input centroids
+			# we need to check and see if some of these objects have
+			# potentially disappeared
+			if D.shape[0] >= D.shape[1]:
+				# loop over the unused row indexes
+				for row in unusedRows:
+					# grab the object ID for the corresponding row
+					# index and increment the disappeared counter
+					objectID = objectIDs[row]
+					self.disappeared[objectID] += 1
+
+					# check to see if the number of consecutive
+					# frames the object has been marked "disappeared"
+					# for warrants deregistering the object
+					if self.disappeared[objectID] > self.maxDisappeared:
+						self.deregister(objectID)
+
+			# otherwise, if the number of input centroids is greater
+			# than the number of existing object centroids we need to
+			# register each new input centroid as a trackable object
+			else:
+				for col in unusedCols:
+					self.register(inputCentroids[col])
+
+		# return the set of trackable objects
+		return self.objects

scripts/utils/edge_utils.py

+from scripts.common.constants import JanusDeploymentConstants
+from scripts.common.config import MONGO_DB_OBJ, APP_MONGO_COLLECTION
+
+
+def get_extra_fields(device_id):
+    _janus_deployment = MONGO_DB_OBJ[APP_MONGO_COLLECTION.get(JanusDeploymentConstants.JANUS_DEPLOYMENT_COLLECTION)]. \
+            find_one({JanusDeploymentConstants.DEPLOYMENT_ID: device_id}).get(JanusDeploymentConstants.EXTRA_FIELDS_KEY)
+    if _janus_deployment is None:
+        raise ValueError("Janus deployment configuration is not found/corrupted")
+
+    _key_dictionary = dict()
+    for each_field in _janus_deployment:
+        _key_dictionary[each_field['key']] = each_field['value']
+    return _key_dictionary

scripts/utils/image_utils.py

+from edge_engine.common.logsetup import logger
+import cv2
+
+
+def draw_circles_on_frame(frame, point, radius=3, color=(255, 255, 255), thickness=1):
+    """
+    draw circle on the objects
+    :param radius: radius of the circle
+    :param frame: frame to draw on
+    :param point: co-ordinate to draw on
+    :param color: color of the circle
+    :param thickness: thickness of the circle
+    :return: frame
+    """
+    logger.debug("Drawing circle centroid on the frame")
+    return cv2.circle(frame, tuple(point), radius, color, thickness)
+
+
+def resize_to_64_64(frame):
+    """
+    resize the from
+    :param frame: frame
+    :return: frame
+    """
+    logger.debug("Resizing the frame to 64 x 64")
+    return cv2.resize(frame, (64, 64))
\ No newline at end of file

scripts/utils/infocenter.py

+import os
+from datetime import datetime
+from requests import post
+from uuid import uuid1
+from urllib.parse import urljoin
+from edge_engine.common.logsetup import logger
+from scripts.common.config import MONGO_DB_OBJ, APP_MONGO_COLLECTION
+
+
+class MongoLogger:
+    def __init__(self):
+        self.attendance_event_collection = MONGO_DB_OBJ[APP_MONGO_COLLECTION.get('eventLogCollection')]
+        self.camera_configuration = MONGO_DB_OBJ[APP_MONGO_COLLECTION.get('cameraConfigurationCollection')]
+        self.camera_mapping_json = self.get_all_cameras()
+
+    def get_all_cameras(self):
+        camera_mapping_json = self.camera_configuration.find({'decommissioned': False}, {"_id": 0})
+        camera_json = {}
+        for each in camera_mapping_json:
+            camera_json[each['cameraId']] = each['cameraName']
+        return camera_json
+
+    # @staticmethod
+    # def update_count_api(**kwargs):
+    #     asset_id = os.environ.get('asset_id')
+    #     asset_hierarchy = os.environ.get('asset_hierarchy')
+    #     count_update_endpoint = os.environ.get('count_update_endpoint')
+    #     logger.debug("count_update_endpoint",count_update_endpoint)
+    #     if asset_id is not None and count_update_endpoint is not None and asset_hierarchy is not None:
+    #         response = post(url=count_update_endpoint,
+    #                         json=dict(asset_hierarchy=asset_hierarchy, count_increment=1, asset_id=asset_id,**kwargs), timeout=5)
+    #         if response.status_code != 200:
+    #             logger.warning(
+    #                 "Value not updated in cards!. Invalid response from Update Count API: {}".format(response.content))
+    #     else:
+    #         logger.warning("Either asset_id, asset_hierarchy or count_update_endpoint is not set!."
+    #                        " Not updating the cards API!")
+
+    def insert_attendance_event_to_mongo(self, data):
+        try:
+            input_data = {
+                "eventId": str(uuid1()).split('-')[0],
+                "cameraId": data['deviceId'],
+                "cameraName": self.camera_mapping_json.get(data['deviceId'], "Thermal Camera"),
+                "timestamp": datetime.now().strftime("%b %d %Y %H:%M:%S"),
+                "frame": data['frame'],
+                "eventtype": "Intrusion Detection",
+                "bg_color": data["bg_color"],
+                "font_color": data["font_color"],
+                "intrusion_message": data["message"],
+                "alert_sound": data["alert_sound"],
+                "logged_activity": data["activity"],
+                "app": "cement"}
+
+            logger.info("Pushing to Mongo..")
+            input_data["timestamp"] = datetime.now()
+            self.attendance_event_collection.insert(input_data)
+            # self.update_count_api(bag_type=data["bag_type"],extra_data={"mrp":data.get("mrp")})
+        except Exception as e:
+            logger.exception(e)
+
+    # def get_camera_details(self, camera_id):
+    #     camera_details_json = self.camera_configuration.find_one({"cameraId": camera_id})
+    #     return camera_details_json
+

scripts/utils/infocenter.py.bkp

+import traceback
+from datetime import datetime
+from uuid import uuid1
+from scripts.common.config import MONGO_DB_OBJ, APP_MONGO_COLLECTION
+from edge_engine.common.logsetup import logger
+import os
+
+class MongoLogger:
+    def __init__(self):
+        self.camera_key = os.environ.get('app',None)
+        self.attendance_event_collection = MONGO_DB_OBJ[APP_MONGO_COLLECTION.get('eventLogCollection')]
+        self.camera_configuration = MONGO_DB_OBJ[APP_MONGO_COLLECTION.get('cameraConfigurationCollection')]
+        self.camera_mapping_json = self.get_all_cameras()
+
+    def get_all_cameras(self):
+        camera_mapping_json = self.camera_configuration.find({'decommissioned': False}, {"_id": 0})
+        camera_json = {}
+        for each in camera_mapping_json:
+            camera_json[each['cameraId']] = each['cameraName']
+        return camera_json
+
+    def insert_attendance_event_to_mongo(self, data):
+        try:
+            input_data = {
+                "eventId": str(uuid1()).split('-')[0],
+                "cameraId": data['deviceId'],
+                "cameraName": self.camera_mapping_json.get(data['deviceId'], "Thermal Camera"),
+                "timestamp": datetime.now().strftime("%b %d %Y %H:%M:%S"),
+                "frame": data['frame'],
+                "eventtype": "Intrusion Detection",
+                "bg_color": data["bg_color"],
+                "font_color": data["font_color"],
+                "intrusion_message": data["message"],
+                "alert_sound": data["alert_sound"],
+                "logged_activity": data["activity"],
+            "app":self.camera_key}
+
+            logger.info("Pushing to Mongo..")
+            input_data["timestamp"] = datetime.now()
+            self.attendance_event_collection.insert(input_data)
+        except Exception as e:
+            logger.info(e)
+            logger.error(traceback.format_exc())

tests/test_CementBagCounter.py

+from os import environ
+
+environ["config"] = '{"MONGO_URI": "mongodb://admin:iLens!8989@192.168.0.220:21017", "MONGO_DATABASE": "ilens_wps", ' \
+                    '"MONGO_DB": "ilens_wps","MONGO_COLLECTION": "janusDeployment", "MONGO_KEY": "deploymentId", ' \
+                    '"MONGO_VALUE": "1b180a0e", "MONGO_SERVICE_COLL": "serviceConfiguration", "MONGO_COLL": ' \
+                    '"serviceConfiguration"  } '
+import unittest
+
+from edge_engine.edge_processor import Pubs
+from edge_engine.common.config import EDGE_CONFIG
+from scripts.cement_counter import CementBagCounter
+
+
+class TestCementBagCounter(unittest.TestCase):
+
+    def test__pre_process(self):
+        self.assertEqual(CementBagCounter(config=EDGE_CONFIG, model_config=EDGE_CONFIG["modelConfig"], pubs=Pubs(),
+                                          device_id=EDGE_CONFIG['deviceId'])._pre_process("5"), '5')