] CONF_ATTRIBUTES = 'attributes' DEFAULT_ATTRIBUTES = [ATTR_AGE, ATTR_GENDER] def validate_attributes(list_attributes): """Validate face attributes.""" for attr in list_attributes: if attr not in SUPPORTED_ATTRIBUTES: raise vol.Invalid("Invalid attribute {0}".format(attr)) return list_attributes PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_ATTRIBUTES, default=DEFAULT_ATTRIBUTES): vol.All(cv.ensure_list, validate_attributes), }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the Microsoft Face detection platform.""" api = hass.data[DATA_MICROSOFT_FACE] attributes = config[CONF_ATTRIBUTES] entities = [] for camera in config[CONF_SOURCE]: entities.append(MicrosoftFaceDetectEntity( camera[CONF_ENTITY_ID], api, attributes, camera.get(CONF_NAME) ))
_LOGGER = logging.getLogger(__name__) CONF_SAVE_FILE_FOLDER = "save_file_folder" CONF_TARGET = "target" DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S" DEFAULT_PORT = 5000 DEFAULT_TARGET = "person" RED = (255, 0, 0) SCAN_INTERVAL = timedelta(days=365) # NEVER SCAN. PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_IP_ADDRESS): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Optional(CONF_TARGET, default=DEFAULT_TARGET): cv.string, vol.Optional(CONF_SAVE_FILE_FOLDER): cv.isdir, }) def get_target(predictions: List, target: str): """ Return only the info for the targets. """ targets = [] for result in predictions: if result["name"] == target: targets.append(result) return targets
CONF_WIDTH = "width" CONF_X_POS = "x_position" CONF_Y_POS = "y_position" DEFAULT_BINARY = "ssocr" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_EXTRA_ARGUMENTS, default=""): cv.string, vol.Optional(CONF_DIGITS): cv.positive_int, vol.Optional(CONF_HEIGHT, default=0): cv.positive_int, vol.Optional(CONF_SSOCR_BIN, default=DEFAULT_BINARY): cv.string, vol.Optional(CONF_THRESHOLD, default=0): cv.positive_int, vol.Optional(CONF_ROTATE, default=0): cv.positive_int, vol.Optional(CONF_WIDTH, default=0): cv.positive_int, vol.Optional(CONF_X_POS, default=0): cv.string, vol.Optional(CONF_Y_POS, default=0): cv.positive_int, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
DEFAULT_MIN_SIZE = (30, 30) DEFAULT_NEIGHBORS = 4 DEFAULT_SCALE = 1.1 DEFAULT_TIMEOUT = 10 SCAN_INTERVAL = timedelta(seconds=2) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_CLASSIFIER, default=None): { cv.string: vol.Any( cv.isfile, vol.Schema({ vol.Required(CONF_FILE): cv.isfile, vol.Optional(CONF_SCALE, DEFAULT_SCALE): float, vol.Optional(CONF_NEIGHBORS, DEFAULT_NEIGHBORS): cv.positive_int, vol.Optional(CONF_MIN_SIZE, DEFAULT_MIN_SIZE): vol.Schema((int, int)) })) } }) def _create_processor_from_config(hass, camera_entity, config): """Create an OpenCV processor from configuration.""" classifier_config = config[CONF_CLASSIFIER] name = '{} {}'.format(config[CONF_NAME], split_entity_id(camera_entity)[1].replace('_', ' '))
CONF_PORT, CONF_PASSWORD, CONF_USERNAME, HTTP_OK, HTTP_UNAUTHORIZED) _LOGGER = logging.getLogger(__name__) ATTR_MODEL_ID = 'model_id' ATTR_MODEL_NAME = 'model_name' CLASSIFIER = 'classificationbox' EVENT_IMAGE_CLASSIFICATION = 'image_processing.image_classification' TIMEOUT = 9 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_IP_ADDRESS): cv.string, vol.Required(CONF_PORT): cv.port, vol.Optional(CONF_USERNAME): cv.string, vol.Optional(CONF_PASSWORD): cv.string, }) def check_box_health(url, username, password): """Check the health of the classifier and return its id if healthy.""" kwargs = {} if username: kwargs['auth'] = requests.auth.HTTPBasicAuth(username, password) try: response = requests.get(url, timeout=TIMEOUT, **kwargs) if response.status_code == HTTP_UNAUTHORIZED: _LOGGER.error("AuthenticationError on %s", CLASSIFIER)
from homeassistant.core import split_entity_id import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) EVENT_PERSON_DETECTED = "sighthound.person_detected" ATTR_BOUNDING_BOX = "bounding_box" ATTR_PEOPLE = "people" CONF_ACCOUNT_TYPE = "account_type" DEV = "dev" PROD = "prod" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_API_KEY): cv.string, vol.Optional(CONF_ACCOUNT_TYPE, default=DEV): vol.In([DEV, PROD]), } ) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the platform.""" # Validate credentials by processing image. api_key = config[CONF_API_KEY] account_type = config[CONF_ACCOUNT_TYPE] api = hound.cloud(api_key, account_type) try: api.detect(b"Test") except hound.SimplehoundException as exc: _LOGGER.error("Sighthound error %s setup aborted", exc) return
import requests import voluptuous as vol from homeassistant.core import split_entity_id import homeassistant.helpers.config_validation as cv from homeassistant.components.image_processing import ( PLATFORM_SCHEMA, ImageProcessingFaceEntity, CONF_SOURCE, CONF_ENTITY_ID, CONF_NAME) from homeassistant.const import (CONF_IP_ADDRESS, CONF_PORT) _LOGGER = logging.getLogger(__name__) CLASSIFIER = 'facebox' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_IP_ADDRESS): cv.string, vol.Required(CONF_PORT): cv.port, }) def encode_image(image): """base64 encode an image stream.""" base64_img = base64.b64encode(image).decode('ascii') return {"base64": base64_img} def get_matched_faces(faces): """Return the name and rounded confidence of matched faces.""" return {face['name']: round(face['confidence'], 2) for face in faces if face['matched']}
vol.Optional(CONF_CONFIDENCE): vol.All( vol.Coerce(float), vol.Range(min=10, max=100) ), } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_IP_ADDRESS): cv.string, vol.Required(CONF_PORT): cv.port, vol.Optional(CONF_API_KEY, default=DEFAULT_API_KEY): cv.string, vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, vol.Optional(CONF_CUSTOM_MODEL, default=""): cv.string, vol.Optional(CONF_TARGETS, default=DEFAULT_TARGETS): vol.All( cv.ensure_list, [vol.Schema(TARGETS_SCHEMA)] ), vol.Optional(CONF_ROI_Y_MIN, default=DEFAULT_ROI_Y_MIN): cv.small_float, vol.Optional(CONF_ROI_X_MIN, default=DEFAULT_ROI_X_MIN): cv.small_float, vol.Optional(CONF_ROI_Y_MAX, default=DEFAULT_ROI_Y_MAX): cv.small_float, vol.Optional(CONF_ROI_X_MAX, default=DEFAULT_ROI_X_MAX): cv.small_float, vol.Optional(CONF_SAVE_FILE_FOLDER): cv.isdir, vol.Optional(CONF_SAVE_TIMESTAMPTED_FILE, default=False): cv.boolean, vol.Optional(CONF_SHOW_BOXES, default=True): cv.boolean, vol.Optional(CONF_DATETIME_FORMAT, default=DATETIME_FORMAT): cv.string, } ) Box = namedtuple("Box", "y_min x_min y_max x_max") Point = namedtuple("Point", "y x") def point_in_box(box: Box, point: Point) -> bool:
CONF_HEIGHT = 'height' CONF_ROTATE = 'rotate' CONF_SSOCR_BIN = 'ssocr_bin' CONF_THRESHOLD = 'threshold' CONF_WIDTH = 'width' CONF_X_POS = 'x_position' CONF_Y_POS = 'y_position' DEFAULT_BINARY = 'ssocr' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_EXTRA_ARGUMENTS, default=''): cv.string, vol.Optional(CONF_DIGITS): cv.positive_int, vol.Optional(CONF_HEIGHT, default=0): cv.positive_int, vol.Optional(CONF_SSOCR_BIN, default=DEFAULT_BINARY): cv.string, vol.Optional(CONF_THRESHOLD, default=0): cv.positive_int, vol.Optional(CONF_ROTATE, default=0): cv.positive_int, vol.Optional(CONF_WIDTH, default=0): cv.positive_int, vol.Optional(CONF_X_POS, default=0): cv.string, vol.Optional(CONF_Y_POS, default=0): cv.positive_int, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the Seven segments OCR platform.""" entities = [] for camera in config[CONF_SOURCE]: entities.append(ImageProcessingSsocr( hass, camera[CONF_ENTITY_ID], config, camera.get(CONF_NAME) ))
CONF_API_KEY = 'api_key' CONF_SECRET_KEY = 'secret_key' CONF_SNAPSHOT_FILEPATH = 'snapshot_filepath' CONF_RESIZE = 'resize' CONF_HA_URL = 'ha_url' CONF_HA_PASSWORD = '******' CONF_DETECT_TOP_NUM = 'detect_top_num' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_APP_ID): cv.string, vol.Required(CONF_API_KEY): cv.string, vol.Required(CONF_SECRET_KEY): cv.string, vol.Required(CONF_RESIZE, default='0'): cv.string, vol.Required(CONF_HA_URL): cv.url, vol.Required(CONF_HA_PASSWORD): cv.string, vol.Required(CONF_SNAPSHOT_FILEPATH): cv.string, vol.Optional(CONF_DETECT_TOP_NUM, default=1): cv.positive_int, }) ATTR_USERINFO = 'user_info' ATTR_IMAGE = 'image' ATTR_UID = 'uid' ATTR_GROUPID = 'group_id' DOMAIN = 'image_processing'
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_REGION, default=DEFAULT_REGION): vol.In(SUPPORTED_REGIONS), vol.Required(CONF_ACCESS_KEY_ID): cv.string, vol.Required(CONF_SECRET_ACCESS_KEY): cv.string, vol.Optional(CONF_TARGETS, default=DEFAULT_TARGETS): vol.All(cv.ensure_list, [vol.Schema(TARGETS_SCHEMA)]), vol.Optional(CONF_ROI_Y_MIN, default=DEFAULT_ROI_Y_MIN): cv.small_float, vol.Optional(CONF_ROI_X_MIN, default=DEFAULT_ROI_X_MIN): cv.small_float, vol.Optional(CONF_ROI_Y_MAX, default=DEFAULT_ROI_Y_MAX): cv.small_float, vol.Optional(CONF_ROI_X_MAX, default=DEFAULT_ROI_X_MAX): cv.small_float, vol.Optional(CONF_SCALE, default=DEAULT_SCALE): vol.All(vol.Coerce(float, vol.Range(min=0.1, max=1))), vol.Optional(CONF_SAVE_FILE_FOLDER): cv.isdir, vol.Optional(CONF_SAVE_FILE_FORMAT, default=JPG): vol.In([JPG, PNG]), vol.Optional(CONF_SAVE_TIMESTAMPTED_FILE, default=False): cv.boolean, vol.Optional(CONF_ALWAYS_SAVE_LATEST_FILE, default=False): cv.boolean, vol.Optional(CONF_S3_BUCKET): cv.string, vol.Optional(CONF_SHOW_BOXES, default=True): cv.boolean, vol.Optional(CONF_BOTO_RETRIES, default=DEFAULT_BOTO_RETRIES): vol.All(vol.Coerce(int), vol.Range(min=0)), })
import homeassistant.helpers.config_validation as cv from homeassistant.components.image_processing import (PLATFORM_SCHEMA, ImageProcessingEntity, CONF_SOURCE, CONF_ENTITY_ID, CONF_NAME, DOMAIN) _LOGGER = logging.getLogger(__name__) CONF_ENDPOINT = 'endpoint' CONF_TAGS = 'tags' ROUNDING_DECIMALS = 2 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ENDPOINT): cv.string, vol.Optional(CONF_TAGS, default=[]): vol.All(cv.ensure_list, [cv.string]), }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the classifier.""" entities = [] for camera in config[CONF_SOURCE]: entities.append( Tagbox( camera.get(CONF_NAME), config[CONF_ENDPOINT], camera[CONF_ENTITY_ID], config[CONF_TAGS], ))
'eu', 'fr', 'gb', 'kr', 'kr2', 'mx', 'sg', 'us', 'vn2' ] CONF_REGION = 'region' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_KEY): cv.string, vol.Required(CONF_REGION): vol.All(vol.Lower, vol.In(OPENALPR_REGIONS)), }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the openalpr cloud api platform.""" confidence = config[CONF_CONFIDENCE] params = { 'secret_key': config[CONF_API_KEY], 'tasks': "plate", 'return_image': 0, 'country': config[CONF_REGION], }
from homeassistant.core import split_entity_id import homeassistant.helpers.config_validation as cv from homeassistant.components.image_processing import ( PLATFORM_SCHEMA, CONF_SOURCE, CONF_ENTITY_ID, CONF_NAME) from homeassistant.components.image_processing.microsoft_face_identify import ( ImageProcessingFaceEntity) _LOGGER = logging.getLogger(__name__) CONF_ENDPOINT = 'endpoint' ROUNDING_DECIMALS = 2 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ENDPOINT): cv.string, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the classifier.""" entities = [] for camera in config[CONF_SOURCE]: entities.append(Facebox( camera.get(CONF_NAME), config[CONF_ENDPOINT], camera[CONF_ENTITY_ID] )) add_devices(entities)
ATTR_CONFIDENCE, CONF_CONFIDENCE, CONF_ENTITY_ID, CONF_NAME, CONF_SOURCE, PLATFORM_SCHEMA, ImageProcessingFaceEntity) from homeassistant.components.microsoft_face import DATA_MICROSOFT_FACE from homeassistant.const import ATTR_NAME from homeassistant.core import split_entity_id from homeassistant.exceptions import HomeAssistantError import homeassistant.helpers.config_validation as cv DEPENDENCIES = ['microsoft_face'] _LOGGER = logging.getLogger(__name__) CONF_GROUP = 'group' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_GROUP): cv.slugify, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the Microsoft Face identify platform.""" api = hass.data[DATA_MICROSOFT_FACE] face_group = config[CONF_GROUP] confidence = config[CONF_CONFIDENCE] entities = [] for camera in config[CONF_SOURCE]: entities.append(
DEFAULT_TIMEOUT = 10 DEFAULT_CONFIDENCE = 0.55 DEFAULT_CROP = {'x1': None, 'x2': None, 'y1': None, 'y2': None} SCAN_INTERVAL = timedelta(seconds=30) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_OPTIONS): { vol.Required(CONF_MODEL): cv.isfile, vol.Required(CONF_WEIGHTS): cv.isfile, vol.Required(CONF_LABELS): cv.isfile, vol.Optional(CONF_CROP, DEFAULT_CROP): { vol.Required(CONF_X1): vol.All(vol.Coerce(int), vol.Range(min=0)), vol.Required(CONF_Y1): vol.All(vol.Coerce(int), vol.Range(min=0)), vol.Required(CONF_X2): vol.All(vol.Coerce(int), vol.Range(min=0)), vol.Required(CONF_Y2): vol.All(vol.Coerce(int), vol.Range(min=0)) }, vol.Optional(CONF_CONFIDENCE, DEFAULT_CONFIDENCE): vol.All(vol.Coerce(float), vol.Range(min=0, max=1, max_included=True)) } }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the Darkflow image processing platform.""" try: # Verify that the Darkflow python package is pre-installed # pylint: disable=unused-import,unused-variable
from homeassistant.components.image_processing import ( ATTR_CONFIDENCE, CONF_CONFIDENCE, CONF_ENTITY_ID, CONF_NAME, CONF_SOURCE, PLATFORM_SCHEMA, ImageProcessingFaceEntity) from homeassistant.components.microsoft_face import DATA_MICROSOFT_FACE from homeassistant.const import ATTR_NAME from homeassistant.core import split_entity_id from homeassistant.exceptions import HomeAssistantError import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) CONF_GROUP = 'group' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_GROUP): cv.slugify, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the Microsoft Face identify platform.""" api = hass.data[DATA_MICROSOFT_FACE] face_group = config[CONF_GROUP] confidence = config[CONF_CONFIDENCE] entities = [] for camera in config[CONF_SOURCE]: entities.append(MicrosoftFaceIdentifyEntity( camera[CONF_ENTITY_ID], api, face_group, confidence, camera.get(CONF_NAME)
CONF_ALWAYS_SAVE_LATEST_FILE = "always_save_latest_file" CONF_WATCHED_PLATES = "watched_plates" CONF_MMC = "mmc" DATETIME_FORMAT = "%Y-%m-%d_%H-%M-%S" RED = (255, 0, 0) # For objects within the ROI DEFAULT_REGIONS = ['None'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_TOKEN): cv.string, vol.Optional(CONF_REGIONS, default=DEFAULT_REGIONS): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_MMC, default=False): cv.boolean, vol.Optional(CONF_SAVE_FILE_FOLDER): cv.isdir, vol.Optional(CONF_SAVE_TIMESTAMPTED_FILE, default=False): cv.boolean, vol.Optional(CONF_ALWAYS_SAVE_LATEST_FILE, default=False): cv.boolean, vol.Optional(CONF_WATCHED_PLATES): vol.All(cv.ensure_list, [cv.string]), }) def get_plates(results: List[Dict]) -> List[str]: """ Return the list of candidate plates. If no plates empty list returned. """ plates = []
EVENT_PERSON_DETECTED = "sighthound.person_detected" ATTR_BOUNDING_BOX = "bounding_box" ATTR_PEOPLE = "people" CONF_ACCOUNT_TYPE = "account_type" CONF_SAVE_FILE_FOLDER = "save_file_folder" CONF_SAVE_TIMESTAMPTED_FILE = "save_timestamped_file" DATETIME_FORMAT = "%Y-%m-%d_%H:%M:%S" DEV = "dev" PROD = "prod" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_API_KEY): cv.string, vol.Optional(CONF_ACCOUNT_TYPE, default=DEV): vol.In([DEV, PROD]), vol.Optional(CONF_SAVE_FILE_FOLDER): cv.isdir, vol.Optional(CONF_SAVE_TIMESTAMPTED_FILE, default=False): cv.boolean, } ) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the platform.""" # Validate credentials by processing image. api_key = config[CONF_API_KEY] account_type = config[CONF_ACCOUNT_TYPE] api = hound.cloud(api_key, account_type) try: api.detect(b"Test") except hound.SimplehoundException as exc: _LOGGER.error("Sighthound error %s setup aborted", exc)
) from homeassistant.core import split_entity_id _LOGGER = logging.getLogger(__name__) CONF_API_KEY = "api_key" CONF_TIMEOUT = "timeout" DEFAULT_API_KEY = "" DEFAULT_TIMEOUT = 10 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_IP_ADDRESS): cv.string, vol.Required(CONF_PORT): cv.port, vol.Optional(CONF_API_KEY, default=DEFAULT_API_KEY): cv.string, vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the integration.""" entities = [] for camera in config[CONF_SOURCE]: object_entity = SceneEntity( config.get(CONF_IP_ADDRESS), config.get(CONF_PORT), config.get(CONF_API_KEY),
ATTR_BOUNDING_BOX = 'bounding_box' ATTR_CLASSIFIER = 'classifier' ATTR_IMAGE_ID = 'image_id' ATTR_ID = 'id' ATTR_MATCHED = 'matched' FACEBOX_NAME = 'name' CLASSIFIER = 'facebox' DATA_FACEBOX = 'facebox_classifiers' FILE_PATH = 'file_path' SERVICE_TEACH_FACE = 'facebox_teach_face' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_IP_ADDRESS): cv.string, vol.Required(CONF_PORT): cv.port, vol.Optional(CONF_USERNAME): cv.string, vol.Optional(CONF_PASSWORD): cv.string, }) SERVICE_TEACH_SCHEMA = vol.Schema({ vol.Optional(ATTR_ENTITY_ID): cv.entity_ids, vol.Required(ATTR_NAME): cv.string, vol.Required(FILE_PATH): cv.string, }) def check_box_health(url, username, password): """Check the health of the classifier and return its id if healthy.""" kwargs = {} if username: kwargs['auth'] = requests.auth.HTTPBasicAuth(username, password)
CLASSIFIER_GROUP_CONFIG, CONF_CLASSIFIER, CONF_ENTITY_ID, CONF_NAME, process_image, ) DEPENDENCIES = ['opencv'] _LOGGER = logging.getLogger(__name__) DEFAULT_TIMEOUT = 10 SCAN_INTERVAL = timedelta(seconds=2) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(CLASSIFIER_GROUP_CONFIG) def _create_processor_from_config(hass, camera_entity, config): """Create an OpenCV processor from configurtaion.""" classifier_config = config[CONF_CLASSIFIER] name = '{} {}'.format( config[CONF_NAME], split_entity_id(camera_entity)[1].replace('_', ' ')) processor = OpenCVImageProcessor( hass, camera_entity, name, classifier_config, )
DEFAULT_CLASSIFIER_PATH = 'lbp_frontalface.xml' DEFAULT_MIN_SIZE = (30, 30) DEFAULT_NEIGHBORS = 4 DEFAULT_SCALE = 1.1 DEFAULT_TIMEOUT = 10 SCAN_INTERVAL = timedelta(seconds=2) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_CLASSIFIER): { cv.string: vol.Any( cv.isfile, vol.Schema({ vol.Required(CONF_FILE): cv.isfile, vol.Optional(CONF_SCALE, DEFAULT_SCALE): float, vol.Optional(CONF_NEIGHBORS, DEFAULT_NEIGHBORS): cv.positive_int, vol.Optional(CONF_MIN_SIZE, DEFAULT_MIN_SIZE): vol.Schema((int, int)) }) ) } }) def _create_processor_from_config(hass, camera_entity, config): """Create an OpenCV processor from configuration.""" classifier_config = config.get(CONF_CLASSIFIER) name = '{} {}'.format( config[CONF_NAME], split_entity_id(camera_entity)[1].replace('_', ' '))
from homeassistant.core import split_entity_id from homeassistant.components.image_processing import ( ImageProcessingFaceEntity, PLATFORM_SCHEMA, CONF_SOURCE, CONF_ENTITY_ID, CONF_NAME) import homeassistant.helpers.config_validation as cv REQUIREMENTS = ['face_recognition==1.2.3'] _LOGGER = logging.getLogger(__name__) ATTR_NAME = 'name' CONF_FACES = 'faces' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_FACES): {cv.string: cv.isfile}, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Dlib Face detection platform.""" entities = [] for camera in config[CONF_SOURCE]: entities.append(DlibFaceIdentifyEntity( camera[CONF_ENTITY_ID], config[CONF_FACES], camera.get(CONF_NAME) )) add_entities(entities) class DlibFaceIdentifyEntity(ImageProcessingFaceEntity):
DEFAULT_NEIGHBORS = 4 DEFAULT_SCALE = 1.1 DEFAULT_TIMEOUT = 10 SCAN_INTERVAL = timedelta(seconds=2) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_CLASSIFIER): { cv.string: vol.Any( cv.isfile, vol.Schema({ vol.Required(CONF_FILE): cv.isfile, vol.Optional(CONF_SCALE, DEFAULT_SCALE): float, vol.Optional(CONF_NEIGHBORS, DEFAULT_NEIGHBORS): cv.positive_int, vol.Optional(CONF_MIN_SIZE, DEFAULT_MIN_SIZE): vol.Schema( vol.All(vol.ExactSequence([int, int]), vol.Coerce(tuple))), }), ) } }) def _create_processor_from_config(hass, camera_entity, config): """Create an OpenCV processor from configuration.""" classifier_config = config.get(CONF_CLASSIFIER) name = f"{config[CONF_NAME]} {split_entity_id(camera_entity)[1].replace('_', ' ')}"
from homeassistant.core import split_entity_id import homeassistant.helpers.config_validation as cv from homeassistant.components.image_processing import (PLATFORM_SCHEMA, CONF_SOURCE, CONF_ENTITY_ID, CONF_NAME, ImageProcessingEntity) _LOGGER = logging.getLogger(__name__) CONF_ENDPOINT = 'endpoint' ROUNDING_DECIMALS = 2 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ENDPOINT): cv.string, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the classifier.""" entities = [] for camera in config[CONF_SOURCE]: entities.append( Facebox( camera.get(CONF_NAME), config[CONF_ENDPOINT], camera[CONF_ENTITY_ID], )) add_devices(entities)
cv.string, vol.Optional(CONF_AREA): AREA_SCHEMA, vol.Optional(CONF_CONFIDENCE): vol.Range(min=0, max=100), }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_URL): cv.string, vol.Required(CONF_DETECTOR): cv.string, vol.Required(CONF_TIMEOUT, default=90): cv.positive_int, vol.Optional(CONF_AUTH_KEY, default=""): cv.string, vol.Optional(CONF_FILE_OUT, default=[]): vol.All(cv.ensure_list, [cv.template]), vol.Optional(CONF_CONFIDENCE, default=0.0): vol.Range(min=0, max=100), vol.Optional(CONF_LABELS, default=[]): vol.All(cv.ensure_list, [vol.Any(cv.string, LABEL_SCHEMA)]), vol.Optional(CONF_AREA): AREA_SCHEMA, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Doods client.""" url = config[CONF_URL] auth_key = config[CONF_AUTH_KEY] detector_name = config[CONF_DETECTOR]
SCAN_INTERVAL = timedelta(days=365) # Effectively disable scan. CONF_API_KEY_FILE = "api_key_file" CONF_SAVE_FILE_FOLDER = "save_file_folder" CONF_TARGET = "target" DEFAULT_TARGET = "person" EVENT_OBJECT_DETECTED = "image_processing.object_detected" EVENT_FILE_SAVED = "image_processing.file_saved" FILE = "file" OBJECT = "object" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_KEY_FILE): cv.string, vol.Optional(CONF_TARGET, default=DEFAULT_TARGET): cv.string, vol.Optional(CONF_SAVE_FILE_FOLDER): cv.isdir, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up platform.""" save_file_folder = config.get(CONF_SAVE_FILE_FOLDER) if save_file_folder: save_file_folder = os.path.join(save_file_folder, "") # If no trailing / add it entities = [] for camera in config[CONF_SOURCE]:
CONF_NAME, CONF_SOURCE, PLATFORM_SCHEMA, ImageProcessingFaceEntity, ) from homeassistant.const import ATTR_NAME from homeassistant.core import split_entity_id import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) CONF_FACES = "faces" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_FACES): {cv.string: cv.isfile}, vol.Optional(CONF_CONFIDENCE, default=0.6): vol.Coerce(float), } ) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Dlib Face detection platform.""" entities = [] for camera in config[CONF_SOURCE]: entities.append( DlibFaceIdentifyEntity( camera[CONF_ENTITY_ID], config[CONF_FACES], camera.get(CONF_NAME), config[CONF_CONFIDENCE], )
DEFAULT_TARGET = 'Person' DEFAULT_REGION = 'us-east-1' SUPPORTED_REGIONS = [ 'us-east-1', 'us-east-2', 'us-west-1', 'us-west-2', 'ca-central-1', 'eu-west-1', 'eu-central-1', 'eu-west-2', 'eu-west-3', 'ap-southeast-1', 'ap-southeast-2', 'ap-northeast-2', 'ap-northeast-1', 'ap-south-1', 'sa-east-1' ] REQUIREMENTS = ['boto3 == 1.9.16'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_REGION, default=DEFAULT_REGION): vol.In(SUPPORTED_REGIONS), vol.Required(CONF_ACCESS_KEY_ID): cv.string, vol.Required(CONF_SECRET_ACCESS_KEY): cv.string, }) def get_label_data(response, label_string='Person'): """Get label data.""" for label in response['Labels']: if label['Name'] == label_string: data = {} data['Confidence'] = round(label['Confidence'], 2) data['Instances'] = len(label['Instances']) bounding_boxes = [] for instance in label['Instances']:
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_IP_ADDRESS): cv.string, vol.Required(CONF_PORT): cv.port, vol.Optional(CONF_API_KEY, default=DEFAULT_API_KEY): cv.string, vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, vol.Optional(CONF_CUSTOM_MODEL, default=""): cv.string, vol.Optional(CONF_TARGETS, default=DEFAULT_TARGETS): vol.All(cv.ensure_list, [vol.Schema(TARGETS_SCHEMA)]), vol.Optional(CONF_ROI_Y_MIN, default=DEFAULT_ROI_Y_MIN): cv.small_float, vol.Optional(CONF_ROI_X_MIN, default=DEFAULT_ROI_X_MIN): cv.small_float, vol.Optional(CONF_ROI_Y_MAX, default=DEFAULT_ROI_Y_MAX): cv.small_float, vol.Optional(CONF_ROI_X_MAX, default=DEFAULT_ROI_X_MAX): cv.small_float, vol.Optional(CONF_SCALE, default=DEAULT_SCALE): vol.All(vol.Coerce(float, vol.Range(min=0.1, max=1))), vol.Optional(CONF_SAVE_FILE_FOLDER): cv.isdir, vol.Optional(CONF_SAVE_FILE_FORMAT, default=JPG): vol.In([JPG, PNG]), vol.Optional(CONF_SAVE_TIMESTAMPTED_FILE, default=False): cv.boolean, vol.Optional(CONF_ALWAYS_SAVE_LATEST_FILE, default=False): cv.boolean, vol.Optional(CONF_SHOW_BOXES, default=True): cv.boolean, })
REQUIREMENTS = ['face_recognition==0.2.0'] _LOGGER = logging.getLogger(__name__) ATTR_NAME = 'name' CONF_FACES = 'faces' CONF_KNOWN_FACES = 'keep_known_faces' CONF_UNKNOWN_FACES = 'keep_unknown_faces' DEFAULT_KNOWN_FACES_DIR = 'dlib_known_faces' DEFAULT_UNKNOWN_FACES_DIR = 'dlib_unknown_faces' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_FACES): {cv.string: cv.isfile}, vol.Optional(CONF_KNOWN_FACES, default=False): cv.boolean, vol.Optional(CONF_UNKNOWN_FACES, default=False): cv.boolean, }) def keep_image(image, filename): """Save image for troubleshooting.""" directory = os.path.dirname(filename) if not os.path.isdir(directory): os.mkdir(directory) with open(filename, 'wb') as fdb: fdb.write(image.getvalue())
] CONF_ATTRIBUTES = 'attributes' DEFAULT_ATTRIBUTES = [ATTR_AGE, ATTR_GENDER] def validate_attributes(list_attributes): """Validate face attributes.""" for attr in list_attributes: if attr not in SUPPORTED_ATTRIBUTES: raise vol.Invalid("Invalid attribtue {0}".format(attr)) return list_attributes PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_ATTRIBUTES, default=DEFAULT_ATTRIBUTES): vol.All(cv.ensure_list, validate_attributes), }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the Microsoft Face detection platform.""" api = hass.data[DATA_MICROSOFT_FACE] attributes = config[CONF_ATTRIBUTES] entities = [] for camera in config[CONF_SOURCE]: entities.append(MicrosoftFaceDetectEntity( camera[CONF_ENTITY_ID], api, attributes, camera.get(CONF_NAME) ))
from homeassistant.core import split_entity_id import homeassistant.helpers.config_validation as cv from homeassistant.components.image_processing import ( PLATFORM_SCHEMA, ImageProcessingEntity, CONF_SOURCE, CONF_ENTITY_ID, CONF_NAME) from homeassistant.const import CONF_API_KEY _LOGGER = logging.getLogger(__name__) BASE_URL = "https://dev.sighthoundapi.com/v1/detections" CLASSIFIER = 'sighthound' TIMEOUT = 9 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_KEY): cv.string, }) def encode_image(image): """base64 encode an image stream.""" base64_img = base64.b64encode(image).decode('ascii') return base64_img def parse_api_response(response): """Parse the response from the API. """ faces = [] persons = [] for obj in response.json()['objects']: if obj['type'] == 'face':
}) CATEGORY_SCHEMA = vol.Schema({ vol.Required(CONF_CATEGORY): cv.string, vol.Optional(CONF_AREA): AREA_SCHEMA }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_FILE_OUT, default=[]): vol.All(cv.ensure_list, [cv.template]), vol.Required(CONF_MODEL): vol.Schema({ vol.Required(CONF_GRAPH): cv.isfile, vol.Optional(CONF_AREA): AREA_SCHEMA, vol.Optional(CONF_CATEGORIES, default=[]): vol.All(cv.ensure_list, [vol.Any(cv.string, CATEGORY_SCHEMA)]), vol.Optional(CONF_LABELS): cv.isfile, vol.Optional(CONF_MODEL_DIR): cv.isdir, }), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the TensorFlow image processing platform.""" model_config = config.get(CONF_MODEL) model_dir = model_config.get(CONF_MODEL_DIR) or hass.config.path( "tensorflow")
vol.Optional(CONF_LEFT, default=0): cv.small_float, vol.Optional(CONF_RIGHT, default=1): cv.small_float, vol.Optional(CONF_TOP, default=0): cv.small_float, }) CATEGORY_SCHEMA = vol.Schema({ vol.Required(CONF_CATEGORY): cv.string, vol.Optional(CONF_AREA): AREA_SCHEMA, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_FILE_OUT, default=[]): vol.All(cv.ensure_list, [cv.template]), vol.Required(CONF_MODEL): vol.Schema({ vol.Required(CONF_GRAPH): cv.isfile, vol.Optional(CONF_AREA): AREA_SCHEMA, vol.Optional(CONF_CATEGORIES, default=[]): vol.All(cv.ensure_list, [vol.Any(cv.string, CATEGORY_SCHEMA)]), vol.Optional(CONF_LABELS): cv.isfile, vol.Optional(CONF_MODEL_DIR): cv.isdir, }) }) def draw_box(draw, box, img_width, img_height, text='', color=(255, 255, 0)): """Draw bounding box on image.""" ymin, xmin, ymax, xmax = box (left, right, top, bottom) = (xmin * img_width, xmax * img_width, ymin * img_height, ymax * img_height) draw.line([(left, top), (left, bottom), (right, bottom), (right, top), (left, top)], width=5, fill=color)
"gb", "kr", "kr2", "mx", "sg", "us", "vn2", ] CONF_ALPR_BIN = "alpr_bin" DEFAULT_BINARY = "alpr" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_REGION): vol.All(vol.Lower, vol.In(OPENALPR_REGIONS)), vol.Optional(CONF_ALPR_BIN, default=DEFAULT_BINARY): cv.string, }) async def async_setup_platform( hass: HomeAssistant, config: ConfigType, async_add_entities: AddEntitiesCallback, discovery_info: DiscoveryInfoType | None = None, ) -> None: """Set up the OpenALPR local platform.""" create_issue( hass, "openalpr_local", "pending_removal",
from homeassistant.core import split_entity_id from homeassistant.components.image_processing import ( PLATFORM_SCHEMA, CONF_SOURCE, CONF_ENTITY_ID, CONF_NAME) from homeassistant.components.image_processing.microsoft_face_identify import ( ImageProcessingFaceEntity) import homeassistant.helpers.config_validation as cv REQUIREMENTS = ['face_recognition==0.2.2'] _LOGGER = logging.getLogger(__name__) ATTR_NAME = 'name' CONF_FACES = 'faces' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_FACES): {cv.string: cv.isfile}, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the Dlib Face detection platform.""" entities = [] for camera in config[CONF_SOURCE]: entities.append(DlibFaceIdentifyEntity( camera[CONF_ENTITY_ID], config[CONF_FACES], camera.get(CONF_NAME) )) add_devices(entities) class DlibFaceIdentifyEntity(ImageProcessingFaceEntity):
'fr', 'gb', 'kr', 'kr2', 'mx', 'sg', 'us', 'vn2' ] CONF_ALPR_BIN = 'alp_bin' DEFAULT_BINARY = 'alpr' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_REGION): vol.All(vol.Lower, vol.In(OPENALPR_REGIONS)), vol.Optional(CONF_ALPR_BIN, default=DEFAULT_BINARY): cv.string, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the OpenALPR local platform.""" command = [config[CONF_ALPR_BIN], '-c', config[CONF_REGION], '-'] confidence = config[CONF_CONFIDENCE] entities = [] for camera in config[CONF_SOURCE]: entities.append(OpenAlprLocalEntity( camera[CONF_ENTITY_ID], command, confidence, camera.get(CONF_NAME) ))
DATETIME_FORMAT = "%Y-%m-%d_%H-%M-%S" DEFAULT_API_KEY = "" DEFAULT_TIMEOUT = 10 CLASSIFIER = "deepstack_face" DATA_DEEPSTACK = "deepstack_classifiers" FILE_PATH = "file_path" SERVICE_TEACH_FACE = "deepstack_teach_face" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_IP_ADDRESS): cv.string, vol.Required(CONF_PORT): cv.port, vol.Optional(CONF_API_KEY, default=DEFAULT_API_KEY): cv.string, vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, vol.Optional(CONF_DETECT_ONLY, default=False): cv.boolean, vol.Optional(CONF_SAVE_FILE_FOLDER): cv.isdir, vol.Optional(CONF_SAVE_TIMESTAMPTED_FILE, default=False): cv.boolean, } ) SERVICE_TEACH_SCHEMA = vol.Schema( { vol.Optional(ATTR_ENTITY_ID): cv.entity_ids, vol.Required(ATTR_NAME): cv.string, vol.Required(FILE_PATH): cv.string, } )
"eu", "fr", "gb", "kr", "kr2", "mx", "sg", "us", "vn2", ] CONF_REGION = "region" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_KEY): cv.string, vol.Required(CONF_REGION): vol.All(vol.Lower, vol.In(OPENALPR_REGIONS)), }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the OpenALPR cloud API platform.""" confidence = config[CONF_CONFIDENCE] params = { "secret_key": config[CONF_API_KEY], "tasks": "plate", "return_image": 0, "country": config[CONF_REGION],
'gb', 'kr', 'mx', 'sg', ] CONF_REGION = 'region' CONF_ALPR_BIN = 'alp_bin' DEFAULT_BINARY = 'alpr' DEFAULT_CONFIDENCE = 80 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_REGION): vol.All(vol.Lower, vol.In(OPENALPR_REGIONS)), vol.Optional(CONF_ALPR_BIN, default=DEFAULT_BINARY): cv.string, vol.Optional(CONF_CONFIDENCE, default=DEFAULT_CONFIDENCE): vol.All(vol.Coerce(float), vol.Range(min=0, max=100)) }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the openalpr local platform.""" command = [config[CONF_ALPR_BIN], '-c', config[CONF_REGION], '-'] confidence = config[CONF_CONFIDENCE] entities = [] for camera in config[CONF_SOURCE]: entities.append(OpenAlprLocalEntity( camera[CONF_ENTITY_ID], command, confidence, camera.get(CONF_NAME)