def __init__(self, conf, plugin, idm=False): self._conf = conf self._plugin = plugin self.rules = [] # list of RuleMatch objects Detector.__init__(self, conf, plugin) self.__myDataBaseCursor = None self.__objDBConn = None self.__tries = 0 self.stop_processing = False self._databasetype = self._plugin.get("config", "source_type") self._canrun = True self.__idm = idm if self._databasetype == "db2" and db2notloaded: logger.info( "You need python ibm_db module installed. This is not an error if you aren't using an IBM plugin" ) self._canrun = False elif self._databasetype == "mysql" and mysqlnotloaded: logger.info("You need python mysqldb module installed") self._canrun = False self.stop() elif self._databasetype == "oracle" and oraclenotloaded: logger.info( "You need python cx_Oracle module installed. This is not an error if you aren't using an Oracle plugin" ) self._canrun = False elif self._databasetype == "mssql" and mssqlnotloaded: logger.info("You need python pymssql module installed") self._canrun = False
def __init__(self, image_shape=(720, 1280), step_sizes=[-40, -20, 0, 20, 40], max_guided_eps=1000): self.current_episode = 0 self.max_guided_eps = max_guided_eps self.im_width = image_shape[1] self.im_height = image_shape[0] self.step_sizes = step_sizes self.fig = None self.max_dist = np.linalg.norm([self.im_width, self.im_height]) self.SCALE_IOU = 8.0 self.SCALE_DIST = 1.0 self.min_reward = 0.08 self.current_frame = None self.current_output = None self._detector = Detector() self._connector = MultiRotorConnector() self._car_connector = CarConnector() self.old_x = None self.old_y = None self.TEST = False
def __init__(self, conf, plugin, conn): self._conf = conf # config.cfg info self._plugin = plugin # plugins/X.cfg info self.rules = [] # list of RuleMatch objects self.conn = conn self.stop_processing = False Detector.__init__(self, conf, plugin, conn)
def start(self): self.client_socket, addr = self.server_socket.accept() print("[INFO] connection received from: %s\n" % (addr[0])), data = self.receive_data() frame = self.vf.convert_to_frame(data) self.detector = Detector(frame, EYE_AR_THRESH=0.24, ROLL_THRESH=15, TIME_THRESH=3) while self.client_socket: try: data = self.receive_data() frame = self.vf.convert_to_frame(data) if sys.getsizeof(data) < 40: print("[INFO] Client stopped sending messages") break self.ALARM_ON = self.detector.detect_drowsiness(frame) self.send_alarm_status() if self.vf.show_frame(frame): break except Exception as e: print("[EXCEPTION] ", e) break self.stop()
def find_target(self, frame, following, color=None, type_obj="object"): self.update(frame) if color is None: # se non gli passo nessun colore da cercare, li cerco tutti for detector in self.detectors: mask, rect = detector.find_obj(self.frame) if rect is not None: detector.find_type(self.frame, following) if detector.bounding_box and detector.obj.type == type_obj: # se ho rilevato qualcosa self.target = detector break else: # altrimenti cerco solo quel colore detector = Detector(Object(color)) try: mask, rect = detector.find_obj(self.frame) except TypeError: mask = None rect = None detector.obj.type = "area" if rect is not None and type_obj == "object": detector.find_type(self.frame, following) if detector.bounding_box and detector.obj.type == type_obj: # se ho rilevato qualcosa self.target = detector self.mask = mask if self.target: print "my target is " + self.target.obj.name + " " + self.target.obj.type
def __init__(self, conf, plugin, hostname, username, password): self.__conf = conf self.__plugin = plugin self.__rules = [] # list of RuleMatch objects self.__hostname = hostname self.__username = username self.__password = password.strip() self.__section = self.__plugin.get("config", "section") self.__last_record_time = "" if self.__section == "": #search into the command to find the section rules = self.__plugin.rules() cmd_str = rules['cmd']['cmd'] for sec in ParserWMI.VALID_SECTIONS: if cmd_str.find(sec) >= 0: self.__section = sec logger.warning( "section doesn't found in [config].Section deduced: %s " % self.__section) break if self.__section == "": self.__section = "Security" logger.warning( "section doesn't found in [config].It can't be deduced: Setting it to default value: %s" % self.__section) self.__pluginID = self.__plugin.get("DEFAULT", "plugin_id") self.__stop_processing = False self.__sectionExists = False Detector.__init__(self, conf, plugin)
def __init__(self): Detector.__init__(self) self.state = self.init self.object_contour = None self.object_gripper_expanse = None self.object_center = None
def __init__(self, conf, plugin, conn,idm=False): Detector.__init__(self, conf, plugin, conn) self._conf = conf self._plugin = plugin self.rules = [] # list of RuleMatch objects self.conn = conn self.__myDataBaseCursor = None self.__objDBConn = None self.__tries = 0 self.stop_processing = False self._databasetype = self._plugin.get("config", "source_type") self._canrun = True self.__idm = True if self._plugin.get("config", "idm") == "true" else False self.loginfo(Lazyformat("IDM is {}", "enabled" if self.__idm else "disabled")) if self._databasetype == "db2" and db2notloaded: self.loginfo("You need python ibm_db module installed") self._canrun = False elif self._databasetype == "mysql" and mysqlnotloaded: self.loginfo("You need python mysqldb module installed") self._canrun = False self.stop() elif self._databasetype == "oracle" and oraclenotloaded: self.loginfo("You need python cx_Oracle module installed") self._canrun = False elif self._databasetype == "mssql" and mssqlnotloaded: self.loginfo("You need python pymssql module installed") self._canrun = False
def main(): input_file_name, model_name, show_video = check_args() print(f"Input Video: {input_file_name}") print(f"Model Name: {model_name}") detector = Detector() detector.initialize(model_name, input_file_name) can_read_frames = True current_frame = 0 start_time = time.time() while can_read_frames: current_frame += 1 can_read_frames, frame = detector.analyze_frame(current_frame) print(f"\rAnalyzing Frame {current_frame}", end='') if current_frame % 3 == 0: print(" \\", end='') elif current_frame % 3 == 1: print(" |", end='') elif current_frame % 3 == 2: print(" /", end='') if show_video and frame is not None: cv2.imshow("Frame", frame) cv2.waitKey(1) analyze_time = int(time.time() - start_time) print() print(f"Total Frames: {current_frame}") print(f"Analyze Time: {analyze_time}s") print(f"Average Frames Per Second: {current_frame // analyze_time}")
def main(): if not os.path.isfile(fname): print("Please train the data first") exit(0) videoGetter = Capturer(vSource).start() faceDetector = Detector(dname, cname, fname, videoGetter.frame, relayPin).start() #videoShower = Show(videoGetter.frame).start() # Setup GPIO for door lock GPIO.setmode(GPIO.BCM) GPIO.setup(relayPin, GPIO.OUT) GPIO.output(relayPin, 0) while True: # Stop the thread when its other worker stopped if videoGetter.stopped or faceDetector.stopped: #videoShower.stopped: if not videoGetter.stopped: videoGetter.stop() if not faceDetector.stopped: faceDetector.stop() #if not videoShower.stopped: videoShower.stop() break frame = videoGetter.frame # Capture a video frame faceDetector.frame = frame # Submit the video frame to detector for process #videoShower.frame = frame GPIO.cleanup() print("END")
def __init__( self, device ): # тут бы по хорошему проинициализировать все что у нас написано self.CarCon = CarControl.CarControl( device) # кар контролу передаем девайс которым пользуемся self.Detector = Detector() self.Road = 0 self.map = Map.MyMap( open('graph.txt')) # нам нужна карта для построения маршрута self.Path = [] self.prev = 0 self.startDot = 1 self.finishDot = 18 self.bluesigns = 0 self.walls = [10000, 10000, 10000] self.lines = [10000, 10000] self.frame = np.array([]) self.RedIsON = 0 self.brick = 0 #self.camera = PiCamera() self.camera = cv2.VideoCapture(0) #self.camera.resolution = (CarSettings.PiCameraResW, CarSettings.PiCameraResH) #self.camera.framerate = CarSettings.PiCameraFrameRate #self.camera.vflip = True #self.camera.hflip = True #self.rawCapture = PiRGBArray(self.camera, size=(CarSettings.PiCameraResW, CarSettings.PiCameraResH)) self.crossroad = False self.fullcross = False self.CarCon.turn(CarSettings.DefaultAngle) self.CarCon.move(0, CarSettings.Stop)
def gen(camera): """Video streaming generator function""" while True: global referenceFrame frame = camera.get_frame() data = np.fromstring(frame, dtype=np.uint8) image = cv2.imdecode(data, 1) if referenceFrame is None: _, _, referenceFrame = Detector.generateReferenceImageItem(image) referenceFrameDeque = Detector.generateReferenceImageDeque( referenceFrame, REFERENCE_FRAME_AVERAGE_FRAME_COUNT) referenceFrameLastUpdate = TimeService.getTimestamp() if TimeService.getTimestamp( ) > referenceFrameLastUpdate + REFERENCE_FRAME_UPDATE_INTERVAL_MS: _, _, referenceFrameItem = Detector.generateReferenceImageItem( image) referenceFrameDeque.append(referenceFrameItem) referenceFrame = Detector.generateReferenceImage( referenceFrameDeque) referenceFrameLastUpdate = TimeService.getTimestamp() detectedRegionRectangles, processedImage, deltaImage, thresholdImage = Detector.detect( MIN_HEIGHT, MIN_WIDTH, referenceFrame, image) if DRAW_DETECTED_REGIONS and len(detectedRegionRectangles): for rectangle in detectedRegionRectangles: ImageManipulator.drawRectangleMutable(processedImage, rectangle) yield (b'--frame\r\n' b'Content-Type: image/jpeg\r\n\r\n' + cv2.imencode(".jpeg", processedImage)[1].tostring() + b'\r\n')
def __init__(self, conf, plugin, conn, hostname, username, password): self.__conf = conf self.__plugin = plugin self.__rules = [] # list of RuleMatch objects self.__conn = conn self.__hostname = hostname self.__username = username self.__password = password.strip() self.__section = self.__plugin.get("config", "section") self.__last_record_time = "" if self.__section == "": #search into the command to find the section rules = self.__plugin.rules() cmd_str = rules['cmd']['cmd'] for sec in ParserWMI.VALID_SECTIONS: if cmd_str.find(sec)>=0: self.__section = sec logger.warning("section doesn't found in [config].Section deduced: %s " % self.__section) break if self.__section == "": self.__section = "Security" logger.warning("section doesn't found in [config].It can't be deduced: Setting it to default value: %s" % self.__section) self.__pluginID = self.__plugin.get("DEFAULT", "plugin_id") self.__stop_processing = False self.__sectionExists = False Detector.__init__(self, conf, plugin, conn)
def __init__(self, conf, plugin, conn): Detector.__init__(self, conf, plugin, conn) self.__conf = conf self.__plugin_id = plugin.get("DEFAULT", "plugin_id") self.__shutdown_event = threading.Event() self.__location = self._plugin.get("config", "location") self.__plugin_configuration = plugin
def __get_video__(self): file_dir = filedialog.askopenfilename() filetype = os.path.splitext(file_dir)[1] if len(file_dir) > 0: if filetype in ['.mov']: model = load_model("ModelandPickle/AlexnetRP.model") # Open the computer web cam. cap = cv2.VideoCapture(file_dir) while True: # Capture the frame from the web camera. ret, frame = cap.read() facedector = Detector() face = facedector.detect_face(frame) for (x, y, w, h) in face: color = (0, 0, 255) stroke = 2 cv2.rectangle(frame, (x, y), (x + w, y + h), color, stroke) # Capture the face from the frame and then test it Capture_face = frame[y: y + h, x + 10: x + w - 10] Capture_face = cv2.resize(Capture_face, (Image_size, Image_size)) Capture_face = Capture_face.astype("float") Capture_face = img_to_array(Capture_face) face = np.expand_dims(Capture_face, axis=0) preds = model.predict(face)[0] j = np.argmax(preds) result = int(j) label = image_label[result] if (label == 'real'): label = "{}".format(label) cv2.putText(frame, label, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) elif (label == 'fake'): label = "{}".format(label) cv2.putText(frame, label, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2) cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2) frame = cv2.putText(frame, 'Press Q to exit', (0, 10), cv2.FONT_HERSHEY_COMPLEX, 1.2, (255, 255, 255), 1) # Display the real time frame. cv2.imshow('Face Detection', frame) # If user type Q from the keyboard the loop could be break. if cv2.waitKey(20) & 0xFF == ord('q'): break # Release the resource and destroy all windows. cap.release() cv2.destroyAllWindows() else: messagebox.showerror('error', message='The file type is wrong, please upload .mov file')
class Model(object): def __init__(self, detector_window, classifier_window): self.detector_window = detector_window self.classifier_window = classifier_window self.detector = Detector() self.detector.load() self.classifier = Classifier() self.classifier.load() self.gesture_sequence = Gesture() def __call__(self, hand_landmarks): self.gesture_sequence.push(hand_landmarks) if len(self.gesture_sequence) > self.classifier_window: self.gesture_sequence.drop_first() tail_detect_vector = self.gesture_sequence.data(-self.detector_window) detector_predict = self.detector.predict(tail_detect_vector) if detector_predict: tail_classify_vector = self.gesture_sequence.data( -self.classifier_window) classifier_predict = self.classifier.predict(tail_classify_vector) if classifier_predict != 'No gesture': return classifier_predict else: return None else: return None
class SignThread(Thread ): # поток для детектирования знаков и ситуаций на дороге def __init__(self): Thread.__init__(self) self.Detector = Detector() self.bluesigns = 0 self.RedIsON = False self.mark = False self.frame = np.array([]) self.brick = 0 def run( self ): # по задумке 0-прямая дорога, 1-перекресток, 2-знак,3-препятствие self.mark = True while self.mark: if len(self.frame) > 0: self.brick = self.Detector.DetectRedSign(self.frame, False) self.bluesigns = self.Detector.DetectBlueSign( self.frame, False) self.RedIsON = self.Detector.DetectTrLight( self.frame, False) # 3 - движение вперед 4 - направо 5 - налево 6 - прямо или направо 7 - прямо или налево time.sleep(0.01) def off(self): self.mark = False
def __init__(self, conf, plugin, conn,idm=False): self._conf = conf self._plugin = plugin self.rules = [] # list of RuleMatch objects self.conn = conn Detector.__init__(self, conf, plugin, conn) self.__myDataBaseCursor = None self.__objDBConn = None self.__tries = 0 self.stop_processing = False self._databasetype = self._plugin.get("config", "source_type") self._canrun = True self.__idm = idm if self._databasetype == "db2" and db2notloaded: logger.info("You need python ibm_db module installed. This is not an error if you aren't using an IBM plugin") self._canrun = False elif self._databasetype == "mysql" and mysqlnotloaded: logger.info("You need python mysqldb module installed") self._canrun = False self.stop() elif self._databasetype == "oracle" and oraclenotloaded: logger.info("You need python cx_Oracle module installed. This is not an error if you aren't using an Oracle plugin") self._canrun = False elif self._databasetype == "mssql" and mssqlnotloaded: logger.info("You need python pymssql module installed") self._canrun = False
def recoverServiceFail(self, cluster_id, fail_node_name): cluster = ClusterManager.getCluster(cluster_id) if not cluster: logging.error("RecoverManager : cluster not found") return fail_node = cluster.getNodeByName(fail_node_name) port = int(self.config.get("detection", "polling_port")) version = int(self.config.get("version", "version")) detector = Detector(fail_node, port) fail_services = detector.getFailServices() status = True if "agents" in fail_services: status = self.restartDetectionService(fail_node, version) else: status = self.restartServices(fail_node, fail_services, version) if not status: # restart service fail print "start recovery" print "fail node is %s" % fail_node.name print "start recovery vm" self.recoverVM(cluster, fail_node) print "end recovery vm" return self.recoverNodeByReboot(fail_node) else: return status # restart service success
def __init__(self, conf, plugin, conn, idm=False): Detector.__init__(self, conf, plugin, conn) self._conf = conf self._plugin = plugin self.rules = [] # list of RuleMatch objects self.conn = conn self.__myDataBaseCursor = None self.__objDBConn = None self.__tries = 0 self.stop_processing = False self._databasetype = self._plugin.get("config", "source_type") self._canrun = True self.__idm = True if self._plugin.get("config", "idm") == "true" else False logger.info("IDM is %s for plugin %s" % ("enabled" if self.__idm else "disabled", self._plugin.get("DEFAULT", "plugin_id"))) if self._databasetype == "db2" and db2notloaded: logger.info( "You need python ibm_db module installed. This is not an error if you aren't using an IBM plugin" ) self._canrun = False elif self._databasetype == "mysql" and mysqlnotloaded: logger.info("You need python mysqldb module installed") self._canrun = False self.stop() elif self._databasetype == "oracle" and oraclenotloaded: logger.info( "You need python cx_Oracle module installed. This is not an error if you aren't using an Oracle plugin" ) self._canrun = False elif self._databasetype == "mssql" and mssqlnotloaded: logger.info("You need python pymssql module installed") self._canrun = False
def __init__(self, conf, plugin, conn, idm=False): Detector.__init__(self, conf, plugin, conn) self._conf = conf self._plugin = plugin self.rules = [] # list of RuleMatch objects self.conn = conn self.__myDataBaseCursor = None self.__objDBConn = None self.__tries = 0 self.stop_processing = False self._databasetype = self._plugin.get("config", "source_type") self._canrun = True self.__idm = True if self._plugin.get("config", "idm") == "true" else False self.loginfo( Lazyformat("IDM is {}", "enabled" if self.__idm else "disabled")) if self._databasetype == "db2" and db2notloaded: self.loginfo("You need python ibm_db module installed") self._canrun = False elif self._databasetype == "mysql" and mysqlnotloaded: self.loginfo("You need python mysqldb module installed") self._canrun = False self.stop() elif self._databasetype == "oracle" and oraclenotloaded: self.loginfo("You need python cx_Oracle module installed") self._canrun = False elif self._databasetype == "mssql" and mssqlnotloaded: self.loginfo("You need python pymssql module installed") self._canrun = False
def test_package_calibration(): detector = Detector() handrail_filter = calibrate_from_package_return_handrail_filter() test_img = cv2.imread("Calibration_Images/cal_80cm_45degrees.jpg") detection = detector.get_rects_from_bgr(test_img)[0] print(handrail_filter.get_distance_from_detection(detection))
def main(): r = redis.Redis(host=config.redis.hostname, port=config.redis.port, db=config.redis.db) detector = Detector("/models/hent-AI model 268/weights.h5") detector.load_weights() # Test the connection to Redis. r.get("connection-test") while True: print("ready to receive censored image") key, uuid = r.blpop(["mask-requests:bar", "mask-requests:mosaic"], 0) print("received censored image") censored_img_data = r.get("censored-images:%s" % uuid.decode()) is_mosaic = key.decode() == "mask-requests:mosaic" try: prepared_img = detector.detect_and_mask(ImageProcessor.bytes_to_image(censored_img_data), is_mosaic, 3) print("processed image, saving to redis") r.set("masked-images:%s" % uuid.decode(), ImageProcessor.image_to_bytes(prepared_img)) r.rpush("decensor-requests:%s" % ("mosaic" if is_mosaic else "bar"), "%s" % uuid.decode()) except NoCensoredRegionsFoundError as e: print(e.description) r.set("errors:%s" % uuid.decode(), e.json)
def __init__(self): Detector.__init__(self) self.STATE_COMPONENT_TRAIN = "COMPONENT_TRAIN" self.tag = "keras-" self.exampleBuilder = KerasExampleBuilder self.matrices = None self.arrays = None
def __init__(self, cluster_id, node, detection_list, port, polling_interval): threading.Thread.__init__(self) self.node = node self.cluster_id = cluster_id self.detection_list = detection_list self.clean_detection_list = self.clean_detection() self.ipmi_status = node.ipmi_status self.polling_interval = polling_interval self.loop_exit = False self.config = ConfigParser.RawConfigParser() self.config.read('hass.conf') self.detector = Detector(node, port) self.custom_function_map = self.set_function_map() self.function_map = [ self.detector.checkPowerStatus, self.detector.checkOSStatus, self.detector.checkNetworkStatus, self.detector.checkServiceStatus ] self.active_layer = self.set_active_layer() self.disable_layer = self.set_disable_layer() self.authUrl = "http://" + self.config.get("rpc", "rpc_username") + ":" + self.config.get("rpc", "rpc_password") + \ "@127.0.0.1:" + self.config.get( "rpc", "rpc_bind_port") self.server = xmlrpclib.ServerProxy(self.authUrl)
def __init__(self, conf, plugin, conn): self._conf = conf self._plugin = plugin self.rules = [] self.conn = conn self.sIdFile = '/etc/ossim/agent/sdee_sid.data' Detector.__init__(self, conf, plugin, conn)
def __init__(self): self.known_height = 3.50266 # cm self.known_width = 25.5 # cm self.focal_length_width = -1 self.focal_length_height = -1 self.image_width = 0 self.image_height = 0 self.detector = Detector()
def __init__(self): Detector.__init__(self) # Settings self.STATE_TOOLCHAIN = "PROCESS" self.steps = [] self.intermediateFilesAtSource = False self.compressIntermediateFiles = False self.intermediateFileTag = "temp"
def __init__(self, conf, plugin, queue=None): self._conf = conf # config.cfg info self._plugin = plugin # plugins/X.cfg info self.rules = [] # list of RuleMatch objects self.stop_processing = False self.queue = queue self.idmConnected = False Detector.__init__(self, conf, plugin)
def __init__(self, detector_window, classifier_window): self.detector_window = detector_window self.classifier_window = classifier_window self.detector = Detector() self.detector.load() self.classifier = Classifier() self.classifier.load() self.gesture_sequence = Gesture()
def __init__(self, conf, plugin,queue = None): self._conf = conf # config.cfg info self._plugin = plugin # plugins/X.cfg info self.rules = [] # list of RuleMatch objects self.stop_processing = False self.queue = queue self.idmConnected = False Detector.__init__(self, conf, plugin)
def __init__(self): Thread.__init__(self) self.Detector = Detector() self.bluesigns = 0 self.RedIsON = False self.mark = False self.frame = np.array([]) self.brick = 0
def __init__(self, conf, plugin, conn): self._conf = conf # main agent config file self._plugin = plugin # plugin config file self.conn = conn self._prefix = "" Detector.__init__(self, conf, plugin, self.conn)
def main(): parser = argparse.ArgumentParser() parser.add_argument("-c", "--camera", help="using camera feed", action='store_true') parser.add_argument("-p", "--path", help="path to images") parser.add_argument("-o", "--option", help="options : both, eyes, smile",required=True) parser.add_argument("-d", "--display", help="do you want to display",action='store_true') args = parser.parse_args() if args.camera: images = VideoList('Camera') elif args.path: images = FrameList(args.path) else: raise Exception('must pass either feed or images') source = images.get_source() folder = source.split('/')[-1] save = '../data/Results' if not os.path.exists(save): os.makedirs(save) detector = Detector(option=args.option, debugging=False, save=False) row = 0 workbook = xlsxwriter.Workbook(save + '/' + folder + '.xlsx') worksheet = workbook.add_worksheet() worksheet.write(row, 0, "Image Name") worksheet.write(row, 1, "Results") t = 0 f = 0 #ITERATE OVER ALL IMAGES while not images.is_finished(): name, frame = images.get_frame() value = detector.perfectPhoto(frame) if args.display: frame = cv2.resize(frame,(400,400), interpolation=cv2.INTER_AREA) cv2.imshow("Feed", frame) k = cv2.waitKey(1000) if k & 0xFF == ord('q'): images.stop() row+=1 worksheet.write(row, 0, name) worksheet.write(row,1, value*1) if value: t+=1 else: f+=1 last_row = row + 1 worksheet.write(last_row+1,0, "Predicted Yes") worksheet.write(last_row+1,1, "=COUNTIF(B2:B{},1)".format(last_row) ) worksheet.write(last_row+2 ,0, "Predicted No") worksheet.write(last_row+2,1, "=COUNTIF(B2:B{},0)".format(last_row) ) workbook.close() print("Predicted Yes: {}, Predicted No: {}".format(t,f))
def setWorkDir(self, workDir): Detector.setWorkDir(self, workDir) # for EventDetector # setup components for detector in [ self.triggerDetector, self.edgeDetector, self.unmergingDetector, self.modifierDetector ]: if detector != None: detector.setWorkDir(workDir)
def process(self,root): se = StructureExtractor() se.drawFeature(root) self.extractor = Extractor(root) self.extractor.process() #self.crossP = self.extractor.string2sparse(self.htmlnode.attrib['crossP'],self.extractor.totalheight+1) Config.init() detector = Detector()#Config.nbTLstr) detector.detect(root) self.toolbox.setDetector(detector)
def performAnalyse(self, htmlnode): se = StructureExtractor() se.drawFeature(htmlnode) extractor = Extractor(htmlnode) extractor.process() detector = Detector() detector.detect(htmlnode) (tp, fp, fn) = self.calcAccTitleLine(htmlnode) cerr = self.calcAccColumn(htmlnode) return (tp, fp, fn, cerr)
def __init__(self): Detector.__init__(self) self.triggerDetector = EntityDetector() self.edgeDetector = EdgeDetector() self.unmergingDetector = UnmergingDetector() self.doUnmergingSelfTraining = True #False self.modifierDetector = ModifierDetector() #self.stEvaluator = Evaluators.BioNLP11GeniaTools #self.stWriteScores = False self.STATE_COMPONENT_TRAIN = "COMPONENT_TRAIN" self.tag = "event-"
def __init__(self): Detector.__init__(self) # Settings self.STATE_TOOLCHAIN = "PROCESS" self.steps = [] for step in self.getDefaultSteps(): self.addStep(*step) self.intermediateFilesAtSource = False self.compressIntermediateFiles = True self.intermediateFileTag = "temp" self.modelParameterStringName = None
def __init__(self, conf, plugin, conn, hostname=None, username=None, password=None): self._conf = conf self._plugin = plugin self.rules = [] self.conn = conn self.__hostname = hostname self.__username = username self.__password = password if hostname: self.sIdFile = '/etc/ossim/agent/sdee_sid_%s.data' % hostname else: self.sIdFile = '/etc/ossim/agent/sdee_sid.data' Detector.__init__(self, conf, plugin, conn)
def __init__(self, conf, plugin): self._conf = conf # config.cfg info self._plugin = plugin # plugins/X.cfg info self.rules = [] # list of RuleMatch objects Detector.__init__(self, conf, plugin) self.__tailLock = Lock() self.stop_processing = False self.__locations = [] self.__watchdog = pyinotify.WatchManager() self.__notifier = None#pyinotify.ThreadedNotifier(self.__watchdog, FileEventHandler()) self.__startNotifier = False self.__tails = [] self.__monitorLocations = [] self.__bookmark_dir = ""
def __init__(self, config, plugin_config): ''' config: Agent configuration object plugin_config: Plugin configuration ''' Detector.__init__(self, config, plugin_config, None) self.__keepWorking = False self.__pluginConfig = plugin_config self.__keep_working_v_lock = threading.RLock() self.__logDirectory = "" self.__filePrefix = "" self.__currentOpenedLogFile_fd = None self.__currentOpenedLogFile_name = "" self.__currentOpenedLogFile_size = 0 self.__timestamp = 0 self.__logfiles = [] self.__skipOldEvents = True
def __init__(self, steps=None): Detector.__init__(self) # Settings self.STATE_TOOLCHAIN = "PROCESS" self.group = None self.definedSteps = [] self.definedStepDict = {} self.defineSteps() self.steps = self.getSteps(steps) #self.allSteps = {} #self.allStepsList = [] #self.groups = [] #self.presets = {} #for step in self.getDefaultSteps(): # self.addStep(*step) self.intermediateFilesAtSource = False self.compressIntermediateFiles = True self.intermediateFileTag = "temp" self.modelParameterStringName = None
def get(self): link_open = urllib2.build_opener( urllib2.HTTPCookieProcessor() ) urllib2.install_opener( link_open ) login_params = "data={\"username\":\"Spring\", \"password\":\"[email protected]\", \"mechanism\":\"plain\"}" login_result = link_open.open( config.base_url + config.login_url, login_params ) login_data = login_result.read() logging.info("Receive data " + login_data) print login_data login_json = json.loads(login_data) login_result.close() self.response.headers['Content-Type'] = 'text/plain' #save sessionid for this connection sessionid = login_json["sessionid"] fetchor = Detector( 5, sessionid, login_json['deviceid'] ) fetchor.start() fetchor.run() fetchor.join()
login_json = json.loads(login_data) login_result.close() #save sessionid for this connection sessionid = login_json["sessionid"] print sessionid ''' # get devices device_params = "data={\"sessionid\":\"" + login_json["sessionid"] + "\"}" device_result = link_open.open( base_url + device_url, device_params ); device_data = device_result.read() device_result.close() device_json = json.loads(device_data) ''' # save deviceids boundbox = (100, 100, 150, 150) fetchor = Detector( 5, sessionid, content['deviceid'], boundbox ) fetchor.start() fetchor.join() #fetchor.run() #threadone = myTimer(1,1) #threadtow = myTimer(2,3) #threadone.start() #threadtow.start() print 'OK' finally: print 'Finished'
def DetectorThunk(conn,dir='C:/PAPA Control/',datacount=1000): """An infinite loop for controlling the detector Keyword arguments: conn -- a connection stream for communicating with the main process dir -- the directory in which to save data datacount -- the number of data points to attempts to read at a time The function loops through, either sleeping or recording data. It polls its communication stream and expects a two element tuple. The first element is an event code and the second is a tuple with the arguments for the event. """ det = Detector() #detector object running = False paused = False runnumber = -1 stream = None count = 0 while True: if (not running) and (not conn.poll()): sleep(0.01) continue if conn.poll(): cmd,args=conn.recv() if cmd==QUIT: break elif cmd==START: if runnumber<=0: logging.error("Error: Invalid Run #") continue if not running: stream = open(dir+("%04d"%runnumber)+'.pel','wb') stream.write(det.makeHeader()) det.start() running = True count=0 elif cmd==STOP: if running: det.stop() det.clear() running = False stream.close() stream=None continue elif cmd==PAUSE: logging.info("Pausing Detector") det.stop()#Do NOT clear running = False paused = True elif cmd==RESUME: if paused: logging.info("Resuming") det.start() running = True else: logging.warning("Cannot resume: detector not paused") elif cmd==RUNNUMBER: runnumber = args[0] conn.send("Run # set to %d"%runnumber) elif cmd==DIRECTORY: dir = args[0] elif cmd == N_COUNT: conn.send(count/2)#Correction Needed for 64 Bit Mode elif cmd==PARAM: opt,val=args det.setParam(opt,val) elif cmd == QUERY: conn.send(det.status[args[0]]) #print det.status[args[0]] else: logging.warning("Did not recognize command %d"%cmd) if running: if stream is None: continue try: #Get the number of data points and the data #note that num is the number of 32 bit data #points given by the detector, which may or #may not be the actual number of neutrons, #depending on if the detector is in 32 or #64 bit mode (num,data)=det.read(datacount) except RuntimeError,(err): logging.error(err) break count += num #Pull only the actual data from the buffer if num < datacount: data=data[:num] stream.write(data.tostring()) if num < datacount: stream.flush() sleep(0.01)
from pprint import pprint from Detector import Detector __author__ = 'Rik Smit ([email protected])' projectDirectory = '/home/rik-target/owncloud-rixmit/Studie/Droneproject/dataset/cows/' datasetIds = [ 'DJI_0005_cut_233-244', 'DJI_0007_cut_22-65', 'DJI_0081' ] detector = Detector(projectDirectory, datasetIds) detector.featureType = 'HSV-HIST' detector.classifierType = 'SVM-RBF' runs = 20 for active in [True, False]: print("Testing (active=%s)" % active) results = None for run in range(runs): result = detector.activeLearningTest(active, datasetIdx=1) # use dataset DJI_0007_cut_22-65 as it is big enough if not results: results = result else: results = [x + y for x, y in zip(results, result)] pprint([x / runs for x in results])
class Analyser: def __init__(self): Config.init() self.detector = Detector()#Config.nbTLstr) def analyse(self, xmlfilelist): parser = etree.XMLParser(recover=True) total_tp = 0 total_fp = 0 total_fn = 0 fnfid = {} fpfid = {} cerrs = dict.fromkeys(['AUTHOR', 'COUNT_READ', 'COUNT_REPLY', 'TITLE', 'TM_POST', 'TM_REPLY'],0) cerrfiles = {} num = 0 for xmlfile in xmlfilelist: #print(xmlfile) if num % 200 == 0 : print(num/len(xmlfilelist)) print('REV.150') print('total_tp:', total_tp) print('total_fp:', total_fp) print('total_fn:', total_fn) print('fnfid:', fnfid) print('fpfid:', fpfid) print('cerrs:',cerrs) print('cerrfiles:', cerrfiles) num += 1 root = etree.parse(xmlfile,parser).getroot() htmlnode = root[0] se = StructureExtractor() se.drawFeature(htmlnode) extractor = Extractor(htmlnode) extractor.process() self.detector.detect(htmlnode) (tp, fp, fn) = self.calcAccTitleLine(htmlnode) total_tp += tp total_fp += fp total_fn += fn if fn == 0: cerr = self.calcAccColumn(htmlnode) for k in cerr: cerrs[k] += 1 if len(cerr)>0: cerrfiles[path.basename(xmlfile)] = (cerr, root.attrib['fid']) if fp > 0: #print(xmlfile) fpfid[root.attrib['fid']] = fpfid.get(root.attrib['fid'],0) + 1 if fn > 0: print(xmlfile) fnfid[root.attrib['fid']] = fnfid.get(root.attrib['fid'],0) + 1 print('REV.150') print('total_tp:', total_tp) print('total_fp:', total_fp) print('total_fn:', total_fn) print('fnfid:', fnfid) print('fpfid:', fpfid) print('cerrs:',cerrs) print('cerrfiles:', cerrfiles) def analyseOnce(self, xmlfile): parser = etree.XMLParser(recover=True) root = etree.parse(xmlfile,parser).getroot() htmlnode = root[0] return self.performAnalyse(htmlnode) def performAnalyse(self, htmlnode): se = StructureExtractor() se.drawFeature(htmlnode) extractor = Extractor(htmlnode) extractor.process() detector = Detector() detector.detect(htmlnode) (tp, fp, fn) = self.calcAccTitleLine(htmlnode) cerr = self.calcAccColumn(htmlnode) return (tp, fp, fn, cerr) def calcAccTitleLine(self, root): ptls = set(root.findall('.//*[@predict="{}"]'.format(LABEL['TITLE_LINE']))) ttls = set(root.findall('.//*[@label="{}"]'.format(LABEL['TITLE_LINE']))) tp = len(ptls & ttls) fp = len(ptls) - tp fn = len(ttls) - tp return (tp, fp, fn) def calcAccColumn(self, root): k = 1 columns = {} while True: cs = root.findall('.//*[@column="{}"]'.format(k)) if len(cs) == 0: break columns[k] = set(cs) k += 1 dls = ['AUTHOR', 'COUNT_READ', 'COUNT_REPLY', 'TITLE', 'TM_POST', 'TM_REPLY'] err = set() for key in dls: ts = set(root.findall('.//*[@predict="{}"]//*[@label="{}"]'.format(LABEL['TITLE_LINE'],LABEL[key]))) cs = set() for tmpnode in ts: if tmpnode.tag == 'text': cs.add(tmpnode.getparent()) else: cs.add(tmpnode) if len(cs) == 0: continue for k in columns: if len(columns[k] - cs)/len(columns[k]) < 0.03 or len(cs - columns[k])/len(cs) < 0.03: break else: err.add(key) return err
from pprint import pprint from Detector import Detector __author__ = 'Rik Smit ([email protected])' projectDirectory = '/home/rik-target/owncloud-rixmit/Studie/Droneproject/dataset/cows/' datasetIds = [ 'DJI_0005_cut_233-244', 'DJI_0007_cut_22-65', 'DJI_0081' ] detector = Detector(projectDirectory, datasetIds) detector.featureType = 'HSV-HIST' detector.classifierType = 'SVM-RBF' testtype = 'interset' # or crossset parameterOptions = { # lists of different parameter values that should be tested for the feature descriptors 'channelsSet': [[0, 1, 2], [1], [0, 1]], 'histSizeSet': [32, 8], 'orientationsSet': [1, 2, 4, 8], 'ppcSet': [8, 16, 32], 'cpbSet': [2, 4, 8] } datasetIdx = 0 # used for interset (which set is tested on classifierParameters = { # single paramters that are used for the classifier 'C': [1], 'gamma': [0.1],
def setWorkDir(self, workDir): Detector.setWorkDir(self, workDir) # for EventDetector # setup components for detector in [self.triggerDetector, self.edgeDetector, self.unmergingDetector, self.modifierDetector]: if detector != None: detector.setWorkDir(workDir)
def __init__(self): Config.init() self.detector = Detector()#Config.nbTLstr)
def __init__(self, hosts, user=None, password=None, timeout_sec=3, translator=None): Detector.__init__(self, hosts, user=user, password=password, timeout_sec=timeout_sec, translator=translator) self.__lock = Lock()
from pprint import pprint from Detector import Detector __author__ = 'Rik Smit ([email protected])' projectDirectory = '/home/rik-target/owncloud-rixmit/Studie/Droneproject/dataset/cows/' datasetIds = [ 'DJI_0005_cut_233-244', 'DJI_0007_cut_22-65', 'DJI_0081' ] detector = Detector(projectDirectory, datasetIds) detector.featureType = 'HSV-HIST' detector.classifierType = 'SVM-RBF' datasetIdx = 0 # used for interset (which set is tested on parameterOptions = { # lists of different classifier parameters values that should be tested 'C': [1, 2, 3, 4, 5, 8, 16, 32, 64, 128, 256], 'gamma': [0.1, 1, 10, 100, 1000], 'n_neighbors': [1, 2, 3, 4, 5, 10] } # singleset test detector.gridSearchSingleSet(parameters=parameterOptions, datasetIdx=datasetIdx) # crossset test detector.gridSearch(parameters=parameterOptions)
from pprint import pprint from Detector import Detector __author__ = 'Rik Smit ([email protected])' projectDirectory = '/home/rik-target/owncloud-rixmit/Studie/Droneproject/dataset/cows/' datasetIds = [ 'DJI_0005_cut_233-244', 'DJI_0007_cut_22-65', 'DJI_0081' ] detector = Detector(projectDirectory, datasetIds) detector.featureType = 'HSV-HIST' detector.classifierType = 'SVM-RBF' trainsetIdxs = [0, 1, 2] testsetIdx = 1 displayOptions = { 'enabled': True, # display anything at all 'frame': True, # video frame image 'detections': False, # detected objects 'suppressed_detections': True, 'sliding_window': False, 'ground_truth': False } detector.test_detect(trainsetIdxs, testsetIdx, harvest=True, autoAnnotate=True, displayOptions=displayOptions)
def __init__(self): Detector.__init__(self) self.deleteCombinedExamples = True