class ProcImage():
"""
Class to process images
"""
#======= Process Image =======
def proc_image(self):
"""
Function to process image
"""
#----- No Processing -----
if self.procmode == 0:
self.img_output = self.img_input
#----- Flip Flop -----
elif self.procmode == 1:
self.img_output = cv2.flip(self.img_input, flipCode = 0)
#----- Canny -----
elif self.procmode == 2:
self.img_output = cv2.Canny(self.img_input, 50, 150)
#----- Face Recognition -----
elif self.procmode == 3:
#----- Copy Mat -----
self.img_output = self.img_input.copy()
#----- Get Face Object -----
faces = self.cascade_face.detectMultiScale(
self.img_output,
scaleFactor=1.1,
minNeighbors=3,
flags=cv2.CASCADE_SCALE_IMAGE,
minSize=(0,0)
)
#----- Depict Face region -----
for x, y, w, h in faces:
#----- Depict rectangle for each face -----
cv2.rectangle(
self.img_output,
(x-self.face_margin_x, y-self.face_margin_y),
(x+w+self.face_margin_x, y+h+self.face_margin_y),
COLOR[2],
self.rect_width
)
#======= Get Movies =======
def get_movie(self):
"""
Function to get video
"""
#======= Start Message =======
self.log.output_msg(1, 1, "ProcImage.get_movie() started")
#======= Open Camera =======
with picamera.PiCamera() as camera:
#======= Open Window =======
cv2.namedWindow('input')
cv2.namedWindow('output')
#======= Prepare Video Recorder =======
video = cv2.VideoWriter(
self.output_video,
cv2.VideoWriter_fourcc('H','2','6','4'),
30,
camera.resolution,
self.isColor
)
#======= Capture Movie =======
with picamera.array.PiRGBArray(camera) as stream:
#======= Prepare Stream =======
time.sleep(0.1)
#======= Get Frame Info =======
camera.capture(stream, format='bgr')
self.img_input = stream.array
self.input_height, self.input_width, self.input_channels = self.img_input.shape
#======= Read Stream =======
for frame in camera.capture_continuous(
stream,
format='bgr',
use_video_port=True
):
#======= Read Image =======
self.img_input = frame.array
#======= Write File =======
video.write(self.img_input)
#======= Get Image =======
def get_image(self):
"""
Function to capture image
"""
#======= Start Message =======
self.log.output_msg(1, 1, "ProcImage.get_image() started")
#======= Open Camera =======
with picamera.PiCamera() as camera:
#======= Setup Camera Configuration =======
#----- Setup Resolution -----
if self.resolution == 3:
camera.resolution = (1024, 768)
elif self.resolution == 2:
camera.resolution = (640, 480)
else:
camera.resolution = (320, 240)
#----- Setup Framerate -----
camera.framerate = self.framerate
#----- Read HAAR files -----
if self.procmode == 3:
self.cascade_face = cv2.CascadeClassifier(self.cascade_face)
if self.cascade_face.empty():
self.log.output_msg(1, 1, "Couldn\'t read HAAR file for face recognition")
sys.exit()
#----- Test Image -----
'''
camera.start_preview()
time.sleep(self.standby_time)
camera.stop_preview()
camera.capture(self.output_img)
'''
#======= Open WIndow =======
cv2.namedWindow('input')
cv2.namedWindow('output')
#======= Capture Image =======
with picamera.array.PiRGBArray(camera) as stream:
#======= Read Stream =======
camera.capture(stream, format='bgr')
self.img_input = stream.array
#======= Image Processing =======
self.proc_image()
#======= Display Image =======
cv2.imwrite(self.output_img, self.img_output)
cv2.imshow('input', self.img_input)
cv2.imshow('output', self.img_output)
cv2.waitKey(1000)
cv2.destroyAllWindows()
#======= End Message =======
self.log.output_msg(1, 1, "ProcImage.get_image() ended")
#======= Initialization =======
def __init__(self):
"""
Constructor
"""
#======= Setup Log =======
self.log = Log(os.environ.has_key('NB_LOG_LEVEL'))
#======= Start Message =======
self.log.output_msg(1, 1, "ProcImage.__init__() started")
#======= Setup Resolution =======
if os.environ.has_key('NB_RESOLUTION'):
self.resolution = int(os.environ['NB_RESOLUTION'])
else:
self.resolution = 1
self.log.output_msg(1, 1, "self.resolution = {0}".format(self.resolution))
#======= Setup Framerate =======
if os.environ.has_key('NB_FRAMERATE'):
self.framerate = int(os.environ['NB_FRAMERATE'])
else:
self.framerate = 32
self.log.output_msg(1, 1, "self.framerate = {0}".format(self.framerate))
#======= Setup ProcMode =======
if os.environ.has_key('NB_PROCMODE'):
self.procmode = int(os.environ['NB_PROCMODE'])
else:
self.procmode = 32
self.log.output_msg(1, 1, "self.procmode = {0}".format(self.procmode))
#======= Setup Output Image =======
if os.environ.has_key('NB_OUTPUT_IMG'):
self.output_img = os.environ['NB_OUTPUT_IMG']
else:
self.output_img = 'output'
self.log.output_msg(1, 1, "self.output_img = {0}".format(self.output_img))
#======= Setup Standby Time =======
if os.environ.has_key('NB_STANDBY_TIME'):
self.standby_time = int(os.environ['NB_STANDBY_TIME'])
else:
self.standby_time = 1
self.log.output_msg(1, 1, "self.standby_time = {0}".format(self.standby_time))
#======= Setup Cascade File (Face) =======
if os.environ.has_key('NB_CASCADE_FACE'):
self.cascade_face = os.environ['NB_CASCADE_FACE']
else:
self.cascade_face = os.environ['OPENCV_HOME'] + "/data/haarcascades/haarcascade_frontalface_default.xml"
self.log.output_msg(1, 1, "self.cascade_face = {0}".format(self.cascade_face))
#======= Setup Face Margin X =======
if os.environ.has_key('NB_FACE_MARGIN_X'):
self.face_margin_x = int(os.environ['NB_FACE_MARGIN_X'])
else:
self.face_margin_x = 15
self.log.output_msg(1, 1, "self.face_margin_x = {0}".format(self.face_margin_x))
#======= Setup Face Margin Y =======
if os.environ.has_key('NB_FACE_MARGIN_Y'):
self.face_margin_y = int(os.environ['NB_FACE_MARGIN_Y'])
else:
self.face_margin_y = 30
self.log.output_msg(1, 1, "self.face_margin_y = {0}".format(self.face_margin_y))
#======= Setup Rectangle Width =======
if os.environ.has_key('NB_RECT_WIDTH'):
self.rect_width = int(os.environ['NB_RECT_WIDTH'])
else:
self.rect_width = 4
self.log.output_msg(1, 1, "self.rect_width = {0}".format(self.rect_width))
#======= End Message =======
self.log.output_msg(1, 1, "ProcImage.__init__() ended")
from common import Log
from proc_image import ProcImage
#======= Global Variable =======
log = Log(os.environ.has_key('NB_LOG_LEVEL'))
#======= Main Function =======
if __name__ == '__main__':
#======= Start Message =======
log.output_msg(1, 1, "main() started")
log.output_msg(1, 1, "log.log_level = {0}".format(log.log_level))
#======= Start Process =======
app = ProcImage()
app.get_image()
#======= End Message =======
log.output_msg(1, 1, "main() ended")
class ClassifyImage():
"""
Class to classify images
"""
#======= Load Data =======
def load_data(self):
"""
Function to load datasets from cifer10
"""
#======= Start Message =======
self.log.output_msg(1, 1, "ClassifyImage.load_data() started")
#======= Download Data =======
(self.x_train, self.y_train), (self.x_test,
self.y_test) = cifar10.load_data()
#======= Convert training data into binary style =======
self.y_train = np_utils.to_categorical(self.y_train, self.class_num)
self.y_test = np_utils.to_categorical(self.y_test, self.class_num)
self.log.output_msg(1, 1,
"x_train.shape = {0}".format(self.x_train.shape))
self.log.output_msg(1, 1,
"y_train.shape = {0}".format(self.y_train.shape))
self.log.output_msg(
1, 1, "x_train.shape[0] = {0}".format(self.x_train.shape[0]))
self.log.output_msg(
1, 1, "y_train.shape[0] = {0}".format(self.y_train.shape[0]))
self.log.output_msg(
1, 1, "x_test.shape[0] = {0}".format(self.x_test.shape[0]))
self.log.output_msg(
1, 1, "y_test.shape[0] = {0}".format(self.y_test.shape[0]))
#======= End Message =======
self.log.output_msg(1, 1, "ClassifyImage.load_data() ended")
#======= Preprocessing =======
def preproc(self):
#======= Start Message =======
self.log.output_msg(1, 1, "ClassifyImage.preproc() started")
self.log.output_msg(
1, 1, "x_train[0][0][0] = {0}".format(self.x_train[0][0][0]))
self.log.output_msg(
1, 1, "x_test[0][0][0] = {0}".format(self.x_test[0][0][0]))
self.x_train = self.x_train.astype('float32') / 255.0
self.x_test = self.x_test.astype('float32') / 255.0
self.log.output_msg(
1, 1, "x_train[0][0][0] = {0}".format(self.x_train[0][0][0]))
self.log.output_msg(
1, 1, "x_test[0][0][0] = {0}".format(self.x_test[0][0][0]))
#======= End Message =======
self.log.output_msg(1, 1, "ClassifyImage.preproc() ended")
#======= Classification =======
def run(self):
#======= Start Message =======
self.log.output_msg(1, 1, "ClassifyImage.run() started")
#======= Create Network Model =======
model_module = importlib.import_module(self.model_path)
input_shape = self.x_train.shape[1:]
output_shape = self.class_num
self.log.output_msg(1, 1, "input_shape = {0}".format(input_shape))
self.log.output_msg(1, 1, "output_shape = {0}".format(output_shape))
self.model = model_module.create_model(input_shape, output_shape)
#======= Define Optimization Model =======
sgd = SGD(lr=self.sgd_lr,
decay=self.sgd_decay,
momentum=self.sgd_momentum,
nesterov=True)
self.model.compile(loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy'])
self.model.summary()
#======= Start Training / Validation =======
if (self.data_aug):
self.log.output_msg(1, 1, "Using Data Augmentation")
#======= Data Augmentation =======
dataaug = ImageDataGenerator(
featurewise_center=self.data_aug_fcenter,
samplewise_center=self.data_aug_scenter,
featurewise_std_normalization=self.data_aug_fstdnorm,
samplewise_std_normalization=self.data_aug_sstdnorm,
zca_whitening=self.data_aug_zca,
rotation_range=self.data_aug_rot_range,
width_shift_range=self.data_aug_wshift_range,
height_shift_range=self.data_aug_hshift_range,
horizontal_flip=self.data_aug_hflip,
vertical_flip=self.data_aug_vflip)
#======= Calc Weight Matrix =======
dataaug.fit(self.x_train)
self.model.fit_generator(dataaug.flow(self.x_train,
self.y_train,
batch_size=self.batch_size),
samples_per_epoch=self.x_train.shape[0],
nb_epoch=self.epoch_num,
validation_data=(self.x_test,
self.y_test))
else:
self.log.output_msg(1, 1, "Not using Data Augmentation")
#======= Calc Weight Matrix =======
self.model.fit(self.x_train,
self.y_train,
batch_size=self.batch_size,
nb_epoch=self.epoch_num,
validation_data=(self.x_test, self.y_test),
shuffle=True,
callbacks=[TensorBoard(log_dir=self.log_dir)])
#======= Save Model =======
self.model.save(self.model_path)
#======= End Message =======
self.log.output_msg(1, 1, "ClassifyImage.run() ended")
#======= Initialization =======
def __init__(self):
"""
Constructor
"""
#======= Setup Log =======
self.log = Log(os.environ['SDL_LOG_LEVEL'])
#======= Start Message =======
self.log.output_msg(1, 1, "ClassifyImage.__init__() started")
#======= Setup Log Directory =======
if 'SDL_LOG_DIR' in os.environ:
self.log_dir = os.environ['SDL_LOG_DIR']
else:
self.log_dir = './log'
self.log.output_msg(1, 1, "self.log_dir = {0}".format(self.log_dir))
#======= Setup Model Path =======
if 'SDL_MODEL_PATH' in os.environ:
self.model_path = os.environ['SDL_MODEL_PATH']
else:
self.model_path = "model.sample_cnn"
self.log.output_msg(1, 1,
"self.model_path = {0}".format(self.model_path))
#======= Setup Class Num =======
if 'SDL_CLASS_NUM' in os.environ:
self.class_num = int(os.environ['SDL_CLASS_NUM'])
else:
self.class_num = 10
self.log.output_msg(1, 1,
"self.class_num = {0}".format(self.class_num))
#======= Setup Row Num =======
if 'SDL_ROW_NUM' in os.environ:
self.row_num = int(os.environ['SDL_ROW_NUM'])
else:
self.row_num = 32
self.log.output_msg(1, 1, "self.row_num = {0}".format(self.row_num))
#======= Setup Col Num =======
if 'SDL_COL_NUM' in os.environ:
self.col_num = int(os.environ['SDL_COL_NUM'])
else:
self.col_num = 32
self.log.output_msg(1, 1, "self.col_num = {0}".format(self.col_num))
#======= Set Channel Num =======
if 'SDL_CHANNEL_NUM' in os.environ:
self.channel_num = int(os.environ['SDL_CHANNEL_NUM'])
else:
self.channel_num = 3
self.log.output_msg(1, 1,
"self.channel_num = {0}".format(self.channel_num))
#======= Setup Batch Size =======
if 'SDL_BATCH_SIZE' in os.environ:
self.batch_size = int(os.environ['SDL_BATCH_SIZE'])
else:
self.batch_size = 32
self.log.output_msg(1, 1,
"self.batch_siize = {0}".format(self.batch_size))
#======= Setup Epoch Number =======
if 'SDL_EPOCH_NUM' in os.environ:
self.epoch_num = int(os.environ['SDL_EPOCH_NUM'])
else:
self.epoch_num = 32
self.log.output_msg(1, 1,
"self.epoch_num = {0}".format(self.epoch_num))
#======= Setup SGD Learning Rate =======
if 'SDL_SGD_LR' in os.environ:
self.sgd_lr = float(os.environ['SDL_SGD_LR'])
else:
self.sgd_lr = 0.01
self.log.output_msg(1, 1, "self.sgd_lr = {0}".format(self.sgd_lr))
#======= Setup SGD Decay =======
if 'SDL_SGD_Decay' in os.environ:
self.sgd_decay = float(os.environ['SDL_SGD_DECAY'])
else:
self.sgd_decay = 1e-4
self.log.output_msg(1, 1,
"self.sgd_decay = {0}".format(self.sgd_decay))
#======= Setup SGD Momentum =======
if 'SDL_SGD_MOMENTUM' in os.environ:
self.sgd_momentum = float(os.environ['SDL_SGD_MOMENTUM'])
else:
self.sgd_momentum = 0.9
self.log.output_msg(
1, 1, "self.sgd_momentum = {0}".format(self.sgd_momentum))
#======= Setup Data Augmentation =======
if 'SDL_DATA_AUG' in os.environ:
self.data_aug = bool(os.environ['SDL_DATA_AUG'])
else:
self.data_aug = True
self.log.output_msg(1, 1, "self.data_aug = {0}".format(self.data_aug))
#======= Setup Featurewise Center =======
if 'SDL_DATA_AUG_FCENTER' in os.environ:
self.data_aug_fcenter = bool(os.environ['SDL_DATA_AUG_FCENTER'])
else:
self.data_aug_fcenter = False
self.log.output_msg(
1, 1, "self.data_aug_fcenter = {0}".format(self.data_aug_fcenter))
#======= Setup Samplewise Center =======
if 'SDL_DATA_AUG_SCENTER' in os.environ:
self.data_aug_scenter = bool(os.environ['SDL_DATA_AUG_SCENTER'])
else:
self.data_aug_scenter = False
self.log.output_msg(
1, 1, "self.data_aug_scenter = {0}".format(self.data_aug_scenter))
#======= Setup Featurewise STD Normalization =======
if 'SDL_DATA_AUG_FSTDNORM' in os.environ:
self.data_aug_fstdnorm = bool(os.environ['SDL_DATA_AUG_FSTDNORM'])
else:
self.data_aug_fstdnorm = False
self.log.output_msg(
1, 1,
"self.data_aug_fstdnorm = {0}".format(self.data_aug_fstdnorm))
#======= Setup Samplewise STD Normalization =======
if 'SDL_DATA_AUG_SSTDNORM' in os.environ:
self.data_aug_sstdnorm = bool(os.environ['SDL_DATA_AUG_SSTDNORM'])
else:
self.data_aug_sstdnorm = False
self.log.output_msg(
1, 1,
"self.data_aug_sstdnorm = {0}".format(self.data_aug_sstdnorm))
#======= Setup ZCA Whitening =======
if 'SDL_DATA_AUG_ZCA' in os.environ:
self.data_aug_zca = bool(os.environ['SDL_DATA_AUG_ZCA'])
else:
self.data_aug_zca = False
self.log.output_msg(
1, 1, "self.data_aug_zca = {0}".format(self.data_aug_zca))
#======= Setup Rot Range =======
if 'SDL_DATA_AUG_ROT_RANGE' in os.environ:
self.data_aug_rot_range = int(os.environ['SDL_DATA_AUG_ROT_RANGE'])
else:
self.data_aug_rot_range = 0
self.log.output_msg(
1, 1,
"self.data_aug_rot_range = {0}".format(self.data_aug_rot_range))
#======= Setup Width Shift Range =======
if 'SDL_DATA_AUG_WSHIFT_RANGE' in os.environ:
self.data_aug_wshift_range = int(
os.environ['SDL_DATA_AUG_WSHIFT_RANGE'])
else:
self.data_aug_wshift_range = 0
self.log.output_msg(
1, 1, "self.data_aug_wshift_range = {0}".format(
self.data_aug_wshift_range))
#======= Setup Height Shift Range =======
if 'SDL_DATA_AUG_HSHIFT_RANGE' in os.environ:
self.data_aug_hshift_range = int(
os.environ['SDL_DATA_AUG_HSHIFT_RANGE'])
else:
self.data_aug_hshift_range = 0
self.log.output_msg(
1, 1, "self.data_aug_hshift_range = {0}".format(
self.data_aug_hshift_range))
#======= Setup Horizontal Flip =======
if 'SDL_DATA_AUG_HFLIP' in os.environ:
self.data_aug_hflip = bool(os.environ['SDL_DATA_AUG_HFLIP'])
else:
self.data_aug_hflip = False
self.log.output_msg(
1, 1, "self.data_aug_hflip = {0}".format(self.data_aug_hflip))
#======= Setup Vertical Flip =======
if 'SDL_DATA_AUG_VFLIP' in os.environ:
self.data_aug_vflip = bool(os.environ['SDL_DATA_AUG_VFLIP'])
else:
self.data_aug_vflip = False
self.log.output_msg(
1, 1, "self.data_aug_vflip = {0}".format(self.data_aug_vflip))
#======= End Message =======
self.log.output_msg(1, 1, "ClassifyImage.__init__() ended")
#----- SDL -----
from common import Log
from classify_image import ClassifyImage
#======= Global Variable =======
log = Log(os.environ['SDL_LOG_LEVEL'])
#======= Main Function =======
if __name__ == '__main__':
#======= Start Message =======
log.output_msg(1, 1, "main() started")
log.output_msg(1, 1, "log.log_level = {0}".format(log.log_level))
#======= Start Process =======
app = ClassifyImage()
app.load_data()
app.preproc()
app.run()
#======= End Message =======
log.output_msg(1, 1, "main() ended")
class ProcAlert():
"""
Class to process alert
"""
#======= alert_led =======
def alert_led(self):
"""
Function to light LED
"""
#======= Start Message =======
self.log.output_msg(1, 1, "ProcAlert.alert_led() started")
#======= Switch LED =======
if self.alert_flag == 1:
GPIO.output(self.led_pos, GPIO.HIGH)
else:
GPIO.output(self.led_pos, GPIO.LOW)
#======= End Message =======
self.log.output_msg(1, 1, "ProcAlert.alert_led() ended")
#======= Get Alert =======
def get_alert(self):
"""
Function to capture alert
"""
#======= Start Message =======
self.log.output_msg(1, 1, "ProcAlert.get_alert() started")
#======= Get Alert =======
response = requests.get( self.endpoint )
self.alert_flag = response.json()[0]['alert_flag']
self.log.output_msg(1, 1, "self.alert_flag = {0}".format(self.alert_flag))
#======= End Message =======
self.log.output_msg(1, 1, "ProcAlert.get_alert() ended")
#======= Initialization =======
def __init__(self):
"""
Constructor
"""
#======= Setup Log =======
self.log = Log(os.environ.has_key('NB_LOG_LEVEL'))
#======= Start Message =======
self.log.output_msg(1, 1, "ProcAlert.__init__() started")
#======= Setup ProcMode =======
if os.environ.has_key('NB_PROCMODE'):
self.procmode = int(os.environ['NB_PROCMODE'])
else:
self.procmode = 1
self.log.output_msg(1, 1, "self.procmode = {0}".format(self.procmode))
#======= Setup Waiting Time =======
if os.environ.has_key('NB_WAITING_TIME'):
self.waiting_time = int(os.environ['NB_WAITING_TIME'])
else:
self.waiting_time = 1
self.log.output_msg(1, 1, "self.waiting_time = {0}".format(self.waiting_time))
#======= Setup LED Position =======
if os.environ.has_key('NB_LED_POS'):
self.led_pos = int(os.environ['NB_LED_POS'])
else:
self.led_pos = 11
self.log.output_msg(1, 1, "self.led_pos = {0}".format(self.led_pos))
#======= Setup GPIO =======
GPIO.setmode(GPIO.BOARD)
GPIO.setup(self.led_pos, GPIO.OUT, initial=GPIO.LOW)
#======= Setup Endpoint =======
if os.environ.has_key('NB_ENDPOINT'):
self.endpoint = os.environ['NB_ENDPOINT']
else:
self.endpoint = "http://192.168.1.1:3000/alert/index.json"
self.log.output_msg(1, 1, "self.endpoint = {0}".format(self.endpoint))
#======= End Message =======
self.log.output_msg(1, 1, "ProcImage.__init__() ended")
