def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTModuleInputVideoPipe.__init__(self)
OTPAdaptativeThresholdFilter.__init__(self)
OTModulePlugin.__init__(self, name, iconFile=icon_path)
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video player")
#THRESHOLD
self._blockSize = OTParamSlider("Block size", 3, 3, 1000,varname='_param_tb_block_size')
self._C = OTParamSlider("C", 255, 0, 510,varname='_param_tb_c')
self._adaptiveMethod = OTParamCombo("Adaptive method",varname='_param_tb_adaptive_method')
self._adaptiveMethod.addItem("Mean", cv2.cv.CV_ADAPTIVE_THRESH_MEAN_C)
self._adaptiveMethod.addItem("Gaussian", cv2.cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C)
self._th_thresholdType = OTParamCombo("ThresholdType",varname='_param_tb_threshold_type')
self._th_thresholdType.addItem("THRESH_BINARY", cv2.THRESH_BINARY)
self._th_thresholdType.addItem("THRESH_BINARY_INV", cv2.THRESH_BINARY_INV)
#END THRESHOLD
self._adaptiveMethod.valueUpdated = self.refreshValue
self._blockSize.valueUpdated = self.refreshValue
self._C.valueUpdated = self.refreshValue
self._formset = [
'_video',"_player",
('_adaptiveMethod','_th_thresholdType'),
('_blockSize',"_C"),
]
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'icon.jpg')
OTModuleResultsPlugin.__init__(self, name, iconFile=icon_path)
self._positions = OTParamPositions("Positions")
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video player")
self._nobjects = OTParamSlider("Number of objects to track", 1, 1, 10)
self._run = OTParamButton("Run")
self._apply = OTParamButton("Apply changes")
self._progress = OTParamProgress()
#self._query.readOnly = True
self._run.value = self.run
self._apply.value = self.apply
self._video.valueUpdated = self.newVideoInputChoosen
self._player.processFrame = self.processFrame
self._query.form.tableView.keyPressEvent = self.keyPressEvent
self._current_row = None
self._formset = [('_video', "_positions", '_nobjects', '_run'),
'_player', '=', ("_results", '_apply'), "_query",
"_progress"]
self._progress.hide()
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTPConvertColor.__init__(self)
OTModulePlugin.__init__(self, name, iconFile=icon_path)
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video player")
self._colorDomain = OTParamCombo("Colors space",
varname='_param_color_domain')
self._colorDomain.addItem("RGB", -1)
self._colorDomain.addItem("GRAY", cv2.COLOR_BGR2GRAY)
self._colorDomain.addItem("XYZ", cv2.COLOR_BGR2XYZ)
self._colorDomain.addItem("YCrCb", cv2.COLOR_BGR2YCR_CB)
self._colorDomain.addItem("HSV", cv2.COLOR_BGR2HSV)
self._colorDomain.addItem("HLS", cv2.COLOR_BGR2HLS)
self._colorDomain.addItem("Lab", cv2.COLOR_BGR2LAB)
self._colorDomain.addItem("Luv", cv2.COLOR_BGR2LUV)
self._colorDomain.valueUpdated = self.refreshValue
self._formset = [
'_video',
'_colorDomain',
"_player",
]
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'icongeo.png')
OTBaseModuleGeometry.__init__(self,name, iconFile = icon_path)
self._imgWidth = 0.0
self._imgHeight = 0.0
self._startPoint = None
self._endPoint = None
self._selectedPoly = None
self._selectedPoint = None
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video")
self._remove = OTParamButton("Remove")
self._square = OTParamToggle("Square")
self._circle = OTParamToggle("Circle")
self._export = OTParamButton("Export")
self._import = OTParamButton("Import")
self._formset = [ '_video',"_player", ("_square", "_circle", " ","_remove"," ", "_export", "_import"), "=", "_polygons" ]
self._video.valueUpdated = self.videoSelected
self._square.value = self.square_toggle
self._circle.value = self.circle_toggle
self._remove.value = self.remove_clicked
self._export.value = self.export_clicked
self._import.value = self.import_clicked
self._player._videoWidget.onDrag = self.onDragInVideoWindow
self._player._videoWidget.onEndDrag = self.onEndDragInVideoWindow
self._player._videoWidget.onClick = self.onClickInVideoWindow
self._player._videoWidget.onDoubleClick = self.onDoubleClickInVideoWindow
self._player.processFrame = self.processFrame
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTModuleInputVideoPipe.__init__(self)
OTPAdaptativeThreshold.__init__(self)
OTModulePlugin.__init__(self, name, iconFile=icon_path)
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video player")
#THRESHOLD
self._blockSize = OTParamSlider("Block size", 3, 3, 500,varname='_param_tb_block_size')
self._C = OTParamSlider("C", 0, 0, 500,varname='_param_tb_c')
self._adaptiveMethod = OTParamCombo("Adaptive method",varname='_param_tb_adaptive_method')
self._adaptiveMethod.addItem("Mean", cv2.cv.CV_ADAPTIVE_THRESH_MEAN_C)
self._adaptiveMethod.addItem("Gaussian", cv2.cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C)
self._th_colorDomain = OTParamCombo("Colors space",varname='_param_tb_color_domain')
self._th_colorDomain.addItem("RGB", -1)
self._th_colorDomain.addItem("Gray", cv2.COLOR_BGR2GRAY)
self._th_colorDomain.addItem("XYZ", cv2.COLOR_BGR2XYZ)
self._th_colorDomain.addItem("YCrCb", cv2.COLOR_BGR2YCR_CB)
self._th_colorDomain.addItem("HSV", cv2.COLOR_BGR2HSV)
self._th_colorDomain.addItem("HLS", cv2.COLOR_BGR2HLS)
self._th_colorDomain.addItem("Lab", cv2.COLOR_BGR2LAB)
self._th_colorDomain.addItem("Luv", cv2.COLOR_BGR2LUV)
self._colorComponent = OTParamCombo("Component",varname='_param_tb_color_component')
self._colorComponent.addItem("A", 0)
self._colorComponent.addItem("B", 1)
self._colorComponent.addItem("C", 2)
self._th_thresholdType = OTParamCombo("ThresholdType",varname='_param_tb_threshold_type')
self._th_thresholdType.addItem("THRESH_BINARY", cv2.THRESH_BINARY)
self._th_thresholdType.addItem("THRESH_BINARY_INV", cv2.THRESH_BINARY_INV)
#END THRESHOLD
self._th_colorDomain.valueUpdated = self.refreshValue
self._colorComponent.valueUpdated = self.refreshValue
self._adaptiveMethod.valueUpdated = self.refreshValue
self._blockSize.valueUpdated = self.refreshValue
self._C.valueUpdated = self.refreshValue
self._formset = [
'_video',"_player",
('_th_colorDomain','_colorComponent','_adaptiveMethod','_th_thresholdType'),
('_blockSize',"_C"),
]
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconbgcalc.jpg')
OTModulePlugin.__init__(self, name, iconFile=icon_path)
self._video = OTParamVideoInput("Video")
self._jumpFrame = OTParamSlider("Frame jump step", 1000, 1, 4000)
self._jump2Frame = OTParamSlider("Compare frame", 1500, 1, 4000)
self._threshold = OTParamSlider("Threshold", 5, 0, 255)
self._export = OTParamButton("Export")
self._editMode = OTParamCheckBox("Edit mode", False)
self._run = OTParamButton("Run")
self._player = OTParamPlayer("Video player")
self._progress = OTParamProgress()
self._formset = [('_video', '_run', '_editMode', '_export'),
('_jumpFrame', '_jump2Frame', '_threshold'),
"_player", "_progress"]
self._run.value = self.run
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
self._export.value = self.export_clicked
self._backgroundDetector = None
self._progress.hide()
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTModulePlugin.__init__(self, name, iconFile=icon_path)
OTPThreshImage.__init__(self)
OTPThreshBlobs.__init__(self)
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video player")
self._polygons = OTParamGeometry("Geometry")
self._blockSize = OTParamSlider("Block size", 3, 3, 500,varname='_param_tb_block_size')
self._C = OTParamSlider("C", 0, 0, 500,varname='_param_tb_c')
self._boxWidth = OTParamSlider("Width", 0, 0, 30,varname='_param_tb_box_width')
self._boxHeight = OTParamSlider("Height", 0, 0, 30,varname='_param_tb_box_height')
self._adaptiveMethod = OTParamCombo("Adaptive method",varname='_param_tb_adaptive_method')
self._adaptiveMethod.addItem("Mean", cv2.cv.CV_ADAPTIVE_THRESH_MEAN_C)
self._adaptiveMethod.addItem("Gaussian", cv2.cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C)
self._colorDomain = OTParamCombo("Colors space",varname='_param_tb_color_domain')
self._colorDomain.addItem("RGB", -1)
self._colorDomain.addItem("Gray", cv2.COLOR_BGR2GRAY)
self._colorDomain.addItem("XYZ", cv2.COLOR_BGR2XYZ)
self._colorDomain.addItem("YCrCb", cv2.COLOR_BGR2YCR_CB)
self._colorDomain.addItem("HSV", cv2.COLOR_BGR2HSV)
self._colorDomain.addItem("HLS", cv2.COLOR_BGR2HLS)
self._colorDomain.addItem("Lab", cv2.COLOR_BGR2LAB)
self._colorDomain.addItem("Luv", cv2.COLOR_BGR2LUV)
self._colorComponent = OTParamCombo("Component",varname='_param_tb_color_component')
self._colorComponent.addItem("A", 0)
self._colorComponent.addItem("B", 1)
self._colorComponent.addItem("C", 2)
self._formset = [
('_video','_polygons'),"_player",('_colorDomain','_colorComponent','_adaptiveMethod'), ('_boxWidth', '_boxHeight'),('_blockSize',"_C")
]
self._colorDomain.valueUpdated = self.refreshValue
self._colorComponent.valueUpdated = self.refreshValue
self._adaptiveMethod.valueUpdated = self.refreshValue
self._boxHeight.valueUpdated = self.refreshValue
self._boxWidth.valueUpdated = self.refreshValue
self._blockSize.valueUpdated = self.refreshValue
self._C.valueUpdated = self.refreshValue
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTModulePlugin.__init__(self, name, iconFile=icon_path)
self._video1 = OTParamVideoInput("Video 1")
self._video2 = OTParamVideoInput("Video 2")
self._player = OTParamPlayer("Video player")
self._formset = [('_video1', '_video2'), "_player"]
self._player.processFrame = self.processFrame
self._video1.valueUpdated = self.newVideoInputChoosen
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconvi.jpg')
super(OTModuleVideoInput, self).__init__(name, iconFile=icon_path)
OTModuleInputVideo.__init__(self)
self._file = OTParamFile("File")
self._player = OTParamPlayer("Video", varname='__capture')
self._progress = OTParamProgress()
self._formset = ["_file", "_player", "_progress"]
self._file.valueUpdated = self.videoSelected
self._progress.hide()
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTPSplitColors.__init__(self)
OTModulePlugin.__init__(self, name, iconFile=icon_path)
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video player")
self._colorComponent = OTParamCombo("Component",
varname='_split_color_channel')
self._colorComponent.addItem("A", 0)
self._colorComponent.addItem("B", 1)
self._colorComponent.addItem("C", 2)
self._colorComponent.valueUpdated = self.refreshValue
self._formset = [
'_video',
'_colorComponent',
"_player",
]
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTModulePlugin.__init__(self, name, iconFile=icon_path)
OTPFindBlobs.__init__(self)
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video player")
self._minArea = OTParamSlider("Blob min. area", 100, 0, 50000, varname='_param_min_area')
self._maxArea = OTParamSlider("Blob max. area", 10000, 0, 100000, varname='_param_max_area')
self._formset = [ '_video', ('_minArea','_maxArea'), "_player" ]
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTModulePlugin.__init__(self, name, iconFile=icon_path)
OTPSelectBiggerBlobs.__init__(self)
self._video = OTParamVideoInput("Video")
self._blobs = OTParamModuleConnection("Blobs", connecting=OTModuleBlobs)
self._player = OTParamPlayer("Video player")
self._howMany = OTParamSlider("How many?", 1, 1, 20, varname='_param_n_blobs')
self._formset = ['_video','_blobs', '_howMany', "_player" ]
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'centre.png')
super(OTModuleCircleCenter, self).__init__(name, iconFile=icon_path)
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video")
self._run = OTParamButton("Run")
self._formset = [('_video', '_run'), "_player"]
self._video.valueUpdated = self.videoSelected
self._run.value = self.__run
self._center = None
self._player.processFrame = self.processFrame
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'radius.png')
OTBaseModuleGeometry.__init__(self, name, iconFile=icon_path)
self._video = OTParamVideoInput("Video")
self._circlecenter = OTParamModuleConnection(
"Circle center", connecting=OTModuleCircleCenter)
self._player = OTParamPlayer("Video")
self._run = OTParamButton("Run")
self._formset = [('_video', '_circlecenter', '_run'), "_player", "=",
'_polygons']
self._video.valueUpdated = self.videoSelected
self._run.value = self.__run
self._radius = None
self._player.processFrame = self.processFrame
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconmask.jpg')
OTModulePlugin.__init__(self, name, iconFile=icon_path)
OTModuleInputVideoPipe.__init__(self)
self._polygons = OTParamModuleConnection(
"Polygons", connecting=OTBaseModuleGeometry)
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video")
self._formset = ['_video', "_polygons", "_player"]
self._video.valueUpdated = self.videoSelected
self._polygons.valueUpdated = self.polygonsSelected
self._player.processFrame = self.processFrame
self._mask_color = None
self._mask_gray = None
class OTModuleColorFilter(OTModulePlugin,OTModuleInputVideo,OTModulePositions, OTPRemoveBackground, OTPColorFilter, OTPAdaptativeThreshold, OTPBlur, OTPMaskImage,OTPCanny, OTPFindBlobs, OTPSelectBiggerBlobs):
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTPRemoveBackground.__init__(self)
OTPColorFilter.__init__(self)
OTPAdaptativeThreshold.__init__(self)
OTPBlur.__init__(self)
OTPFindBlobs.__init__(self)
OTPSelectBiggerBlobs.__init__(self)
OTPMaskImage.__init__(self)
OTPCanny.__init__(self)
OTModulePlugin.__init__(self, name, iconFile=icon_path)
self._video = OTParamVideoInput("Video")
#self._polygons = OTParamGeometry("Geometry")
self._background = OTParamBackground("Background", varname='_param_background')
self._threshold = OTParamSlider("Threshold", 110, 1, 255, varname='_param_background_threshold')
self._minArea = OTParamSlider("Blob min. area",100, 0, 50000, varname='_param_min_area')
self._maxArea = OTParamSlider("Blob max. area", 10000, 0, 100000, varname='_param_max_area')
self._textAlgo = OTParamText("Blob function ( Operations: [ AND: * ; OR: + ; SUB: - ; NEG: ~ ] Ex: A+B-~C )", "A*B*C", varname='_param_filter_algorithm')
self._removeBg = OTParamCheckBox("Remove the background", True)
self._player = OTParamPlayer("Video player")
self._selectBiggests = OTParamCheckBox("Select only the biggests blobs", True)
self._howMany = OTParamSlider("How many?", 1, 1, 20, varname='_param_n_blobs')
self._useBlur = OTParamCheckBox("Use blur", True)
self._kernelSize = OTParamSlider("Kernel size",1, 1, 50, varname='_param_kernel_size')
self._blurThreshold = OTParamSlider("Blur threshold", 110, 1, 255, varname='_param_blur_threshould')
self._colorDomain = OTParamCombo("Colors space", varname='_param_color_domain')
self._colorDomain.addItem("RGB", -1)
self._colorDomain.addItem("XYZ", cv2.COLOR_BGR2XYZ)
self._colorDomain.addItem("YCrCb", cv2.COLOR_BGR2YCR_CB)
self._colorDomain.addItem("HSV", cv2.COLOR_BGR2HSV)
self._colorDomain.addItem("HLS", cv2.COLOR_BGR2HLS)
self._colorDomain.addItem("Lab", cv2.COLOR_BGR2LAB)
self._colorDomain.addItem("Luv", cv2.COLOR_BGR2LUV)
self._activeR = OTParamCheckBox("Active")
self._activeG = OTParamCheckBox("Active")
self._activeB = OTParamCheckBox("Active")
self._minR = OTParamSlider("min. A", 1, 0, 255, varname='_param_a_min')
self._maxR = OTParamSlider("max. A", 255, 0, 255, varname='_param_a_max')
self._minG = OTParamSlider("min. B", 1, 0, 255, varname='_param_b_min')
self._maxG = OTParamSlider("max. B", 255, 0, 255, varname='_param_b_max')
self._minB = OTParamSlider("min. C", 1, 0, 255, varname='_param_c_min')
self._maxB = OTParamSlider("max. C", 255, 0, 255, varname='_param_c_max')
#THRESHOLD
self._blockSize = OTParamSlider("Block size", 3, 3, 500,varname='_param_tb_block_size')
self._C = OTParamSlider("C", 0, 0, 500,varname='_param_tb_c')
self._boxWidth = OTParamSlider("Width", 0, 0, 30,varname='_param_tb_box_width')
self._boxHeight = OTParamSlider("Height", 0, 0, 30,varname='_param_tb_box_height')
self._adaptiveMethod = OTParamCombo("Adaptive method",varname='_param_tb_adaptive_method')
self._adaptiveMethod.addItem("Mean", cv2.cv.CV_ADAPTIVE_THRESH_MEAN_C)
self._adaptiveMethod.addItem("Gaussian", cv2.cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C)
self._th_colorDomain = OTParamCombo("Colors space",varname='_param_tb_color_domain')
self._th_colorDomain.addItem("RGB", -1)
self._th_colorDomain.addItem("Gray", cv2.COLOR_BGR2GRAY)
self._th_colorDomain.addItem("XYZ", cv2.COLOR_BGR2XYZ)
self._th_colorDomain.addItem("YCrCb", cv2.COLOR_BGR2YCR_CB)
self._th_colorDomain.addItem("HSV", cv2.COLOR_BGR2HSV)
self._th_colorDomain.addItem("HLS", cv2.COLOR_BGR2HLS)
self._th_colorDomain.addItem("Lab", cv2.COLOR_BGR2LAB)
self._th_colorDomain.addItem("Luv", cv2.COLOR_BGR2LUV)
self._colorComponent = OTParamCombo("Component",varname='_param_tb_color_component')
self._colorComponent.addItem("A", 0)
self._colorComponent.addItem("B", 1)
self._colorComponent.addItem("C", 2)
self._th_thresholdType = OTParamCombo("ThresholdType",varname='_param_tb_threshold_type')
self._th_thresholdType.addItem("THRESH_BINARY", cv2.THRESH_BINARY)
self._th_thresholdType.addItem("THRESH_BINARY_INV", cv2.THRESH_BINARY_INV)
#END THRESHOLD
#CANNY
self._canny_apertureSize = OTParamSlider("Aperture size", 3, 3, 7, varname='_param_canny_apertureSize')
self._canny_L2gradient = OTParamCheckBox("L2 gradient", True, varname='_param_canny_L2gradient')
self._canny_threshould1 = OTParamSlider("Threshould 1", 0, 0, 255, varname='_param_canny_threshould1')
self._canny_threshould2 = OTParamSlider("Threshould 2", 1, 0, 255, varname='_param_canny_threshould2')
self._canny_colorDomain = OTParamCombo("Colors space",varname='_param_canny_color_domain')
self._canny_colorDomain.addItem("RGB", -1)
self._canny_colorDomain.addItem("Gray", cv2.COLOR_BGR2GRAY)
self._canny_colorDomain.addItem("XYZ", cv2.COLOR_BGR2XYZ)
self._canny_colorDomain.addItem("YCrCb", cv2.COLOR_BGR2YCR_CB)
self._canny_colorDomain.addItem("HSV", cv2.COLOR_BGR2HSV)
self._canny_colorDomain.addItem("HLS", cv2.COLOR_BGR2HLS)
self._canny_colorDomain.addItem("Lab", cv2.COLOR_BGR2LAB)
self._canny_colorDomain.addItem("Luv", cv2.COLOR_BGR2LUV)
self._canny_colorComponent = OTParamCombo("Component",varname='_param_canny_color_component')
self._canny_colorComponent.addItem("A", 0)
self._canny_colorComponent.addItem("B", 1)
self._canny_colorComponent.addItem("C", 2)
#END CANNY
self._useColors = OTParamCheckBox("Use colors filter", True)
self._useThreshold = OTParamCheckBox("Use adaptative threshold", False)
self._useCanny = OTParamCheckBox("Use canny algorithm", False)
self._exportFindBlobs = OTParamCheckBox("Export find blobs", True)
self._canny_colorDomain.valueUpdated = self.refreshValue
self._canny_colorComponent.valueUpdated = self.refreshValue
self._canny_apertureSize.valueUpdated = self.refreshValue
self._canny_L2gradient.valueUpdated = self.refreshValue
self._canny_threshould1.valueUpdated = self.refreshValue
self._canny_threshould2.valueUpdated = self.refreshValue
self._th_colorDomain.valueUpdated = self.refreshValue
self._colorComponent.valueUpdated = self.refreshValue
self._adaptiveMethod.valueUpdated = self.refreshValue
self._boxHeight.valueUpdated = self.refreshValue
self._boxWidth.valueUpdated = self.refreshValue
self._blockSize.valueUpdated = self.refreshValue
self._C.valueUpdated = self.refreshValue
self._colorDomain.valueUpdated = self.refreshValue
self._activeR.valueUpdated = self.refreshValue
self._activeG.valueUpdated = self.refreshValue
self._activeB.valueUpdated = self.refreshValue
self._minR.valueUpdated = self.refreshValue
self._maxR.valueUpdated = self.refreshValue
self._minG.valueUpdated = self.refreshValue
self._maxG.valueUpdated = self.refreshValue
self._minB.valueUpdated = self.refreshValue
self._maxB.valueUpdated = self.refreshValue
self._textAlgo.valueUpdated = self.refreshValue
self._threshold.valueUpdated = self.refreshValue
self._kernelSize.valueUpdated = self.refreshValue
self._blurThreshold.valueUpdated = self.refreshValue
self._maxArea.valueUpdated = self.refreshValue
self._minArea.valueUpdated = self.refreshValue
self._removeBg.valueUpdated = self.removeBgUpdate
self._useBlur.valueUpdated = self.useBlurUpdate
self._selectBiggests.valueUpdated = self.selectBiggestsUpdate
self._useColors.valueUpdated = self.__useColorsClicked
self._useThreshold.valueUpdated = self.__useThresholdClicked
self._useCanny.valueUpdated = self.__useCannyClicked
self._formset = [
('_video',' ','_useColors','_useThreshold','_useCanny'),
[
"_player",{
"Remove background": [ '_removeBg','_background', '_threshold'],
"Filter colors" : ['_colorDomain', ("_minR",'_activeR',"_maxR"), ("_minG",'_activeG',"_maxG"), ("_minB",'_activeB',"_maxB")],
"Threshold filter": [('_th_colorDomain','_colorComponent','_adaptiveMethod','_th_thresholdType'), ('_boxWidth', '_boxHeight'),('_blockSize',"_C")],
"Canny": [ ('_canny_colorDomain', '_canny_colorComponent'), '_canny_threshould1','_canny_threshould2','_canny_apertureSize','_canny_L2gradient'],
"Filter objects": [ ('_minArea', '_maxArea'), ('_useBlur', '_kernelSize', '_blurThreshold'), ("_selectBiggests", "_howMany"),'_exportFindBlobs' ],
},"_textAlgo"
]
]
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
self._blurThreshold.hide()
self._kernelSize.hide()
self._background.hide()
self._threshold.hide()
self._howMany.hide()
def __useColorsClicked(self, value):
if value==2:
self._useCanny.enabled = True
self._useThreshold.enabled = True
self._useThreshold.uncheck()
self._useCanny.uncheck()
self._useColors.enabled = False
self.hideTab("Threshold filter")
self.showTab("Filter colors")
self.hideTab("Canny")
self._player.refresh()
def __useThresholdClicked(self, value):
if value==2:
self._useCanny.enabled = True
self._useColors.enabled = True
self._useCanny.uncheck()
self._useColors.uncheck()
self._useThreshold.enabled = False
self.showTab("Threshold filter")
self.hideTab("Filter colors")
self.hideTab("Canny")
self._player.refresh()
def __useCannyClicked(self, value):
if value==2:
self._useThreshold.enabled = True
self._useColors.enabled = True
self._useThreshold.uncheck()
self._useColors.uncheck()
self._useCanny.enabled = False
self.hideTab("Threshold filter")
self.hideTab("Filter colors")
self.showTab("Canny")
self._player.refresh()
def initForm(self):
super(OTModuleColorFilter, self).initForm()
self.hideTab("Threshold filter")
self.hideTab("Canny")
def refreshValue(self, value):
self._player.refresh()
def selectBiggestsUpdate(self, value):
if value:
self._howMany.show()
else:
self._howMany.hide()
self._player.refresh()
def useBlurUpdate(self, value):
if value:
self._kernelSize.show()
self._blurThreshold.show()
else:
self._kernelSize.hide()
self._blurThreshold.hide()
self._player.refresh()
def removeBgUpdate(self, value):
if value:
self._background.show()
self._threshold.show()
else:
self._background.hide()
self._threshold.hide()
self._player.refresh()
def newVideoInputChoosen(self, value):
OTParamVideoInput.valueUpdated(self._video,value)
if value:
self._player.value = value
self.videoInput = value
if isinstance(value, OTModuleMaskFromGeometry):
self._param_mi_polygons = value._all_polygons
self._param_mi_mask = None
def processFrame(self, frame):
original = frame.copy()
if self._removeBg.value:
self._param_background = self._background.value
frame = OTPRemoveBackground.compute(self, frame)
if self._useThreshold.value:
fish = OTPAdaptativeThreshold.compute(self, frame)
elif self._useCanny.value:
fish = OTPCanny.compute(self, frame)
else:
fish = OTPColorFilter.compute(self, frame)
if self._useBlur.value: fish = OTPBlur.compute(self, fish)
if isinstance(self._video.value, OTModuleMaskFromGeometry):
fish = OTPMaskImage.compute(self, fish)
self._objectsFound = OTPFindBlobs.compute(self, fish)
"""
for obj in self._objectsFound:
mask = zeros_like(original)
cv2.fillPoly( mask, obj._contour, (255, 255, 255) )
res = cv2.bitwise_and(original, mask)
b,g,r = cv2.split(res)
b_avg = mean(b[b>0])
g_avg = mean(g[g>0])
r_avg = mean(r[r>0])
obj._color = b_avg, g_avg, r_avg
"""
if self._selectBiggests.value: self._objectsFound = OTPSelectBiggerBlobs.compute(self, self._objectsFound)
################################################################
################################################################
contours2Display = []
for obj in self._objectsFound: contours2Display.append( obj._contour )
cv2.drawContours( frame, array(contours2Display), -1, (0, 255, 0), 1 )
for i, obj in enumerate(self._objectsFound):
cv2.circle(frame, obj._centroid, 5, (255,0,0), thickness=1)
p = obj._bounding[0]
text = "AREA: %d" % obj._area
#cv2.putText(frame, text, p , cv2.FONT_HERSHEY_SIMPLEX, 0.3, (255, 255, 255), 3)
#cv2.putText(frame, text, p , cv2.FONT_HERSHEY_SIMPLEX, 0.3, (0, 0, 255), 1)
if self._useColors.value:
if self._removeBg.value: original = OTPRemoveBackground.compute(self, original)
if self._colorDomain.value>=0: original = cv2.cvtColor(original, self._colorDomain.value)
r,g,b = cv2.split( original )
if not self._activeR.value: r = r * 0
if not self._activeG.value: g = g * 0
if not self._activeB.value: b = b * 0
r = cv2.inRange(r, array(self._minR.value), array(self._maxR.value) )
g = cv2.inRange(g, array(self._minG.value), array(self._maxG.value) )
b = cv2.inRange(b, array(self._minB.value), array(self._maxB.value) )
image = cv2.merge( (b,g,r) )
return [frame, image, fish]
else:
return [frame, fish]
def exportCodeTo(self, folder):
files_to_copy = []
classes, imports, constructer_params, parameters = [], [], [], []
#classes_tmp, imports_tmp, constructer_params_tmp, parameters_tmp = self._video.value.exportCodeTo(folder)
#classes += classes_tmp; imports += imports_tmp; constructer_params += constructer_params_tmp; parameters += parameters_tmp;
#SET OTPRemoveBackground
if self._removeBg.value:
classes_tmp, imports_tmp, constructer_params_tmp, parameters_tmp = self._background.value.exportCodeTo(folder)
classes += classes_tmp; imports += imports_tmp; constructer_params += constructer_params_tmp; parameters += parameters_tmp;
files_to_copy.append( 'OTPRemoveBackground' )
parameters.append("self._param_background_threshold = %d " % self._threshold.value )
#END SET
if self._useThreshold.value:
#SET OTPAdaptativeThreshold
files_to_copy.append( 'OTPAdaptativeThreshold' )
parameters.append("self._param_tb_color_component = %d " % self._colorComponent.value )
parameters.append("self._param_tb_color_domain = %d " % self._th_colorDomain.value )
parameters.append("self._param_tb_adaptive_method = %d " % self._adaptiveMethod.value )
parameters.append("self._param_tb_block_size = %d " % self._blockSize.value )
parameters.append("self._param_tb_threshold_type = %d " % self._th_thresholdType.value )
parameters.append("self._param_tb_c = %d " % self._C.value )
#END SET
elif self._useCanny.value:
#SET OTPCanny
files_to_copy.append( 'OTPCanny' )
parameters.append("self._param_canny_apertureSize = %d " % self._canny_apertureSize.value )
parameters.append("self._param_canny_L2gradient = %d " % self._canny_L2gradient.value )
parameters.append("self._param_canny_threshould1 = %d " % self._canny_threshould1.value )
parameters.append("self._param_canny_threshould2 = %d " % self._canny_threshould2.value )
parameters.append("self._param_canny_color_component = %d " % self._canny_colorComponent.value )
parameters.append("self._param_canny_color_domain = %d " % self._canny_colorDomain.value )
#END SET
else:
#SET OTPColorFilter
files_to_copy.append( 'OTPColorFilter' )
parameters.append("self._param_color_domain = %d " % self._colorDomain.value )
parameters.append("self._param_filter_algorithm = '%s' " % self._textAlgo.value )
parameters.append("self._param_a_min = %d " % self._minR.value )
parameters.append("self._param_a_max = %d " % self._maxR.value )
parameters.append("self._param_b_min = %d " % self._minG.value )
parameters.append("self._param_b_max = %d " % self._maxG.value )
parameters.append("self._param_c_min = %d " % self._minB.value )
parameters.append("self._param_c_max = %d " % self._maxB.value )
#END SET
#SET OTPBlur
if self._useBlur.value:
files_to_copy.append( 'OTPBlur' )
parameters.append("self._param_kernel_size = %d " % self._kernelSize.value )
parameters.append("self._param_blur_threshould = %d " % self._blurThreshold.value )
#END SET
#SET OTPMaskImage
if isinstance(self._video.value, OTModuleMaskFromGeometry):
files_to_copy.append( 'OTPMaskImage' )
parameters.append("self._param_mi_polygons = np.array(%s)" % str(self._video.value._all_polygons) )
imports.append("import numpy as np")
#END SET
#SET OTPFindBlobs
if self._exportFindBlobs.value:
files_to_copy.append( 'OTPFindBlobs' )
parameters.append("self._param_min_area = %d " % self._minArea.value )
parameters.append("self._param_max_area = %d " % self._maxArea.value )
#END SET
#SET OTPSelectBiggerBlobs
if self._selectBiggests.value:
files_to_copy.append( 'OTPSelectBiggerBlobs' )
parameters.append('self._param_n_blobs = %d' % self._howMany.value )
#END SET
classes += files_to_copy
for file_to_copy in files_to_copy:
filename = file_to_copy+".py"; originalfilepath = tools.getFileInSameDirectory(__file__, filename); destinyfilepath = os.path.join( folder, filename )
f = open(originalfilepath, 'r'); text = f.read(); f.close(); text = text.replace("from mcvgui.core.controllers.", "from "); f = open(destinyfilepath, 'w'); f.write(text); f.close()
imports.append( "from %s import %s" % (file_to_copy, file_to_copy) )
return classes, imports, constructer_params, parameters
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTPRemoveBackground.__init__(self)
OTPColorFilter.__init__(self)
OTPAdaptativeThreshold.__init__(self)
OTPBlur.__init__(self)
OTPFindBlobs.__init__(self)
OTPSelectBiggerBlobs.__init__(self)
OTPMaskImage.__init__(self)
OTPCanny.__init__(self)
OTModulePlugin.__init__(self, name, iconFile=icon_path)
self._video = OTParamVideoInput("Video")
#self._polygons = OTParamGeometry("Geometry")
self._background = OTParamBackground("Background", varname='_param_background')
self._threshold = OTParamSlider("Threshold", 110, 1, 255, varname='_param_background_threshold')
self._minArea = OTParamSlider("Blob min. area",100, 0, 50000, varname='_param_min_area')
self._maxArea = OTParamSlider("Blob max. area", 10000, 0, 100000, varname='_param_max_area')
self._textAlgo = OTParamText("Blob function ( Operations: [ AND: * ; OR: + ; SUB: - ; NEG: ~ ] Ex: A+B-~C )", "A*B*C", varname='_param_filter_algorithm')
self._removeBg = OTParamCheckBox("Remove the background", True)
self._player = OTParamPlayer("Video player")
self._selectBiggests = OTParamCheckBox("Select only the biggests blobs", True)
self._howMany = OTParamSlider("How many?", 1, 1, 20, varname='_param_n_blobs')
self._useBlur = OTParamCheckBox("Use blur", True)
self._kernelSize = OTParamSlider("Kernel size",1, 1, 50, varname='_param_kernel_size')
self._blurThreshold = OTParamSlider("Blur threshold", 110, 1, 255, varname='_param_blur_threshould')
self._colorDomain = OTParamCombo("Colors space", varname='_param_color_domain')
self._colorDomain.addItem("RGB", -1)
self._colorDomain.addItem("XYZ", cv2.COLOR_BGR2XYZ)
self._colorDomain.addItem("YCrCb", cv2.COLOR_BGR2YCR_CB)
self._colorDomain.addItem("HSV", cv2.COLOR_BGR2HSV)
self._colorDomain.addItem("HLS", cv2.COLOR_BGR2HLS)
self._colorDomain.addItem("Lab", cv2.COLOR_BGR2LAB)
self._colorDomain.addItem("Luv", cv2.COLOR_BGR2LUV)
self._activeR = OTParamCheckBox("Active")
self._activeG = OTParamCheckBox("Active")
self._activeB = OTParamCheckBox("Active")
self._minR = OTParamSlider("min. A", 1, 0, 255, varname='_param_a_min')
self._maxR = OTParamSlider("max. A", 255, 0, 255, varname='_param_a_max')
self._minG = OTParamSlider("min. B", 1, 0, 255, varname='_param_b_min')
self._maxG = OTParamSlider("max. B", 255, 0, 255, varname='_param_b_max')
self._minB = OTParamSlider("min. C", 1, 0, 255, varname='_param_c_min')
self._maxB = OTParamSlider("max. C", 255, 0, 255, varname='_param_c_max')
#THRESHOLD
self._blockSize = OTParamSlider("Block size", 3, 3, 500,varname='_param_tb_block_size')
self._C = OTParamSlider("C", 0, 0, 500,varname='_param_tb_c')
self._boxWidth = OTParamSlider("Width", 0, 0, 30,varname='_param_tb_box_width')
self._boxHeight = OTParamSlider("Height", 0, 0, 30,varname='_param_tb_box_height')
self._adaptiveMethod = OTParamCombo("Adaptive method",varname='_param_tb_adaptive_method')
self._adaptiveMethod.addItem("Mean", cv2.cv.CV_ADAPTIVE_THRESH_MEAN_C)
self._adaptiveMethod.addItem("Gaussian", cv2.cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C)
self._th_colorDomain = OTParamCombo("Colors space",varname='_param_tb_color_domain')
self._th_colorDomain.addItem("RGB", -1)
self._th_colorDomain.addItem("Gray", cv2.COLOR_BGR2GRAY)
self._th_colorDomain.addItem("XYZ", cv2.COLOR_BGR2XYZ)
self._th_colorDomain.addItem("YCrCb", cv2.COLOR_BGR2YCR_CB)
self._th_colorDomain.addItem("HSV", cv2.COLOR_BGR2HSV)
self._th_colorDomain.addItem("HLS", cv2.COLOR_BGR2HLS)
self._th_colorDomain.addItem("Lab", cv2.COLOR_BGR2LAB)
self._th_colorDomain.addItem("Luv", cv2.COLOR_BGR2LUV)
self._colorComponent = OTParamCombo("Component",varname='_param_tb_color_component')
self._colorComponent.addItem("A", 0)
self._colorComponent.addItem("B", 1)
self._colorComponent.addItem("C", 2)
self._th_thresholdType = OTParamCombo("ThresholdType",varname='_param_tb_threshold_type')
self._th_thresholdType.addItem("THRESH_BINARY", cv2.THRESH_BINARY)
self._th_thresholdType.addItem("THRESH_BINARY_INV", cv2.THRESH_BINARY_INV)
#END THRESHOLD
#CANNY
self._canny_apertureSize = OTParamSlider("Aperture size", 3, 3, 7, varname='_param_canny_apertureSize')
self._canny_L2gradient = OTParamCheckBox("L2 gradient", True, varname='_param_canny_L2gradient')
self._canny_threshould1 = OTParamSlider("Threshould 1", 0, 0, 255, varname='_param_canny_threshould1')
self._canny_threshould2 = OTParamSlider("Threshould 2", 1, 0, 255, varname='_param_canny_threshould2')
self._canny_colorDomain = OTParamCombo("Colors space",varname='_param_canny_color_domain')
self._canny_colorDomain.addItem("RGB", -1)
self._canny_colorDomain.addItem("Gray", cv2.COLOR_BGR2GRAY)
self._canny_colorDomain.addItem("XYZ", cv2.COLOR_BGR2XYZ)
self._canny_colorDomain.addItem("YCrCb", cv2.COLOR_BGR2YCR_CB)
self._canny_colorDomain.addItem("HSV", cv2.COLOR_BGR2HSV)
self._canny_colorDomain.addItem("HLS", cv2.COLOR_BGR2HLS)
self._canny_colorDomain.addItem("Lab", cv2.COLOR_BGR2LAB)
self._canny_colorDomain.addItem("Luv", cv2.COLOR_BGR2LUV)
self._canny_colorComponent = OTParamCombo("Component",varname='_param_canny_color_component')
self._canny_colorComponent.addItem("A", 0)
self._canny_colorComponent.addItem("B", 1)
self._canny_colorComponent.addItem("C", 2)
#END CANNY
self._useColors = OTParamCheckBox("Use colors filter", True)
self._useThreshold = OTParamCheckBox("Use adaptative threshold", False)
self._useCanny = OTParamCheckBox("Use canny algorithm", False)
self._exportFindBlobs = OTParamCheckBox("Export find blobs", True)
self._canny_colorDomain.valueUpdated = self.refreshValue
self._canny_colorComponent.valueUpdated = self.refreshValue
self._canny_apertureSize.valueUpdated = self.refreshValue
self._canny_L2gradient.valueUpdated = self.refreshValue
self._canny_threshould1.valueUpdated = self.refreshValue
self._canny_threshould2.valueUpdated = self.refreshValue
self._th_colorDomain.valueUpdated = self.refreshValue
self._colorComponent.valueUpdated = self.refreshValue
self._adaptiveMethod.valueUpdated = self.refreshValue
self._boxHeight.valueUpdated = self.refreshValue
self._boxWidth.valueUpdated = self.refreshValue
self._blockSize.valueUpdated = self.refreshValue
self._C.valueUpdated = self.refreshValue
self._colorDomain.valueUpdated = self.refreshValue
self._activeR.valueUpdated = self.refreshValue
self._activeG.valueUpdated = self.refreshValue
self._activeB.valueUpdated = self.refreshValue
self._minR.valueUpdated = self.refreshValue
self._maxR.valueUpdated = self.refreshValue
self._minG.valueUpdated = self.refreshValue
self._maxG.valueUpdated = self.refreshValue
self._minB.valueUpdated = self.refreshValue
self._maxB.valueUpdated = self.refreshValue
self._textAlgo.valueUpdated = self.refreshValue
self._threshold.valueUpdated = self.refreshValue
self._kernelSize.valueUpdated = self.refreshValue
self._blurThreshold.valueUpdated = self.refreshValue
self._maxArea.valueUpdated = self.refreshValue
self._minArea.valueUpdated = self.refreshValue
self._removeBg.valueUpdated = self.removeBgUpdate
self._useBlur.valueUpdated = self.useBlurUpdate
self._selectBiggests.valueUpdated = self.selectBiggestsUpdate
self._useColors.valueUpdated = self.__useColorsClicked
self._useThreshold.valueUpdated = self.__useThresholdClicked
self._useCanny.valueUpdated = self.__useCannyClicked
self._formset = [
('_video',' ','_useColors','_useThreshold','_useCanny'),
[
"_player",{
"Remove background": [ '_removeBg','_background', '_threshold'],
"Filter colors" : ['_colorDomain', ("_minR",'_activeR',"_maxR"), ("_minG",'_activeG',"_maxG"), ("_minB",'_activeB',"_maxB")],
"Threshold filter": [('_th_colorDomain','_colorComponent','_adaptiveMethod','_th_thresholdType'), ('_boxWidth', '_boxHeight'),('_blockSize',"_C")],
"Canny": [ ('_canny_colorDomain', '_canny_colorComponent'), '_canny_threshould1','_canny_threshould2','_canny_apertureSize','_canny_L2gradient'],
"Filter objects": [ ('_minArea', '_maxArea'), ('_useBlur', '_kernelSize', '_blurThreshold'), ("_selectBiggests", "_howMany"),'_exportFindBlobs' ],
},"_textAlgo"
]
]
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
self._blurThreshold.hide()
self._kernelSize.hide()
self._background.hide()
self._threshold.hide()
self._howMany.hide()
class OTModuleClusterObjectsPositions(OTModuleResultsPlugin,
OTModulePositions):
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'icon.jpg')
OTModuleResultsPlugin.__init__(self, name, iconFile=icon_path)
self._positions = OTParamPositions("Positions")
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video player")
self._nobjects = OTParamSlider("Number of objects to track", 1, 1, 10)
self._run = OTParamButton("Run")
self._apply = OTParamButton("Apply changes")
self._progress = OTParamProgress()
#self._query.readOnly = True
self._run.value = self.run
self._apply.value = self.apply
self._video.valueUpdated = self.newVideoInputChoosen
self._player.processFrame = self.processFrame
self._query.form.tableView.keyPressEvent = self.keyPressEvent
self._current_row = None
self._formset = [('_video', "_positions", '_nobjects', '_run'),
'_player', '=', ("_results", '_apply'), "_query",
"_progress"]
self._progress.hide()
def newVideoInputChoosen(self, value):
"""
Event called when a user select rows using the popup menu
@param value: Video module
@type value: OTModule
"""
OTParamVideoInput.valueUpdated(self._video, value)
if value.videoInput:
value.videoInput.setFrame(0)
self._player.value = value.videoInput
def apply(self):
updatequery = QtSql.QSqlQuery(self.parentModule.sqldb)
selectquery = QtSql.QSqlQuery(self.parentModule.sqldb)
query = "SELECT a.object, b.id FROM %s a inner join %s b on a.frame=b.frame and a.new_object=b.object WHERE a.new_object<>'' " % (
self._query.table, self._query.table)
selectquery.exec_(query)
while (selectquery.next()):
row = selectquery.record()
obj = int(row.value("object").toString())
rowid = int(row.value("id").toString())
query = "UPDATE %s SET object=%s WHERE id=%s " % (
self._query.table, obj, rowid)
updatequery.exec_(query)
query = "UPDATE %s SET object=new_object WHERE new_object<>'' " % self._query.table
updatequery.exec_(query)
query = "UPDATE %s SET new_object='' " % self._query.table
updatequery.exec_(query)
updatequery.finish()
self._query.orderBy = 1
def keyPressEvent(self, event):
#print event.key()
if event.key() in (16777235, 16777237, 16777233, 16777232, 16777238,
16777239, 16777248):
QTableView.keyPressEvent(self._query.form.tableView, event)
else:
key = event.text()
if event.key() == 16777219 or event.key() == 16777223: key = ""
if key == '' or key in self._results.keys:
for row in self._query.mouseSelectedRowsIndexes:
self._query.setValueIn(row, 13, key)
self._query.commit()
def selectionChanged(self, selected, deselected):
"""
Redefinition of the function selectionChanged from OTModuleResultsPlugin
"""
QTableView.selectionChanged(self._query.form.tableView, selected,
deselected)
row = self._query.mouseSelectedRow
if row != None:
self._current_row = row
video = self._video.value
frame_index = int(row[1]) - 1
video.videoInput.setFrame(frame_index)
self._player.updateFrame()
def processFrame(self, frame, drawSelectedRows=True):
"""
This is an event called by the player before he shows the video frame
@param frame: Frame that would be showed
@type frame: Numpy array
"""
#Draw the current mouse selected row
if self._current_row != None:
x = int(self._current_row[4])
y = int(self._current_row[5])
velocity = eval(str(self._current_row[6]))
accelaration = eval(str(self._current_row[7]))
blob = array([eval(str(self._current_row[8]))])
cv2.circle(frame, (x, y), 6, (0, 0, 255), -1)
cv2.polylines(frame, blob, True, (0, 255, 0), 1)
xx = int(math.ceil(x + velocity[0] + 0.5 * accelaration[0]))
yy = int(math.ceil(y + velocity[1] + 0.5 * accelaration[1]))
cv2.line(frame, (x, y), (xx, yy), (255, 0, 0), 2)
return frame
def __smallestDistance(self, point, positions):
smallest_dist = 1000000
index = -1
for i, values in enumerate(positions):
frame, x, y = int(values[1]), int(values[4]), int(values[5])
dist = tools.pointsDistance(point, (x, y))
if dist <= smallest_dist:
smallest_dist = dist
index = i
return index
def __guessPositions(self, objs_window, nobjects=2):
origin = [None for x in range(nobjects)]
for frameIndex, frame in enumerate(objs_window.get()):
if frameIndex == 0: continue
final_selection = list(origin)
scores = []
for objIndex, obj in enumerate(frame):
for last_obj in objs_window.get(frameIndex - 1):
classification = last_obj.scorePosition(obj._position)
scores.append([classification, last_obj, obj])
scores = sorted(scores, key=lambda x: x[0], reverse=True)
used = []
for score_index in range(len(scores)):
classification, last_object, new_obj = scores[score_index][
0], scores[score_index][1], scores[score_index][2]
#if classification>0.005 and final_selection[last_object._label]==None:
if final_selection[
last_object._label] == None and new_obj not in used:
new_obj.calcEnergyProperties(last_object)
new_obj._label = last_object._label
final_selection[last_object._label] = new_obj
used.append(new_obj)
for i, obj in enumerate(final_selection):
if obj == None:
final_selection[i] = objs_window.get(frameIndex -
1)[i].genNextFrame()
objs_window.set(frameIndex, final_selection)
self._firstTime = False
return objs_window
def __getFirstValues(self, query, nvalues):
sqlquery = QtSql.QSqlQuery(self.parentModule.sqldb)
sqlquery.exec_(query)
results = []
for index in range(nvalues):
sqlquery.next()
row = sqlquery.record()
rowid = int(row.value("id").toString())
frame = int(row.value("frame").toString())
seconds = float(row.value("seconds").toString())
milliseconds = float(row.value("milliseconds").toString())
x = int(row.value("x").toString())
y = int(row.value("y").toString())
obj = str(row.value("polygon").toString())
r = str(row.value("r").toString())
g = str(row.value("g").toString())
b = str(row.value("b").toString())
values = [rowid, frame, seconds, milliseconds, x, y, obj, r, g, b]
results.append(values)
return results
def __row2List(self, row):
rowid = int(row.value("id").toString())
frame = int(row.value("frame").toString())
seconds = float(row.value("seconds").toString())
milliseconds = float(row.value("milliseconds").toString())
x = int(row.value("x").toString())
y = int(row.value("y").toString())
obj = str(row.value("polygon").toString())
r = str(row.value("r").toString())
g = str(row.value("g").toString())
b = str(row.value("b").toString())
return [rowid, frame, seconds, milliseconds, x, y, obj, r, g, b]
def run(self):
totalResults = self._positions.value.countAllResults()
self._progress.min = 0
self._progress.value = 0
self._progress.max = totalResults
self._progress.show()
QApplication.processEvents()
sqlquery = QtSql.QSqlQuery(self.parentModule.sqldb)
insertquery = QtSql.QSqlQuery(self.parentModule.sqldb)
insertquery.exec_("PRAGMA cache_size = 65536")
insertquery.exec_("PRAGMA temp_store = MEMORY")
insertquery.exec_("PRAGMA journal_mode = OFF")
insertquery.exec_("PRAGMA synchronous = OFF")
tablename = "%s_output" % (self.name.replace(" ",
"").lstrip('0123456789.'))
insertquery.exec_("DROP TABLE IF EXISTS %s" % tablename)
insertquery.exec_(
"CREATE TABLE if not exists %s(id INTEGER PRIMARY KEY AUTOINCREMENT, frame BIGINT, seconds DOUBLE, milliseconds BIGINT, x INTEGER, y INTEGER, velocity TEXT, accelaration TEXT, polygon TEXT, r INTEGER, g INTEGER, b INTEGER, object INTEGER, new_object INTEGER)"
% tablename)
count = 0
for query in self._positions.value.getAllQueries():
last_frame, frame_values = -1, []
sqlquery.exec_(query)
valuesWindow = tools.RingBuffer(20)
while (sqlquery.next()):
row = sqlquery.record()
values = self.__row2List(row)
frame = values[1]
if frame != last_frame and last_frame != -1:
#first frame give names to objects
if valuesWindow.count() == 0:
valuesWindow.append([
EnergeticObject(vals, label=i)
for i, vals in enumerate(frame_values)
])
else:
valuesWindow.append(
[EnergeticObject(vals) for vals in frame_values])
#valuesWindow.printValues()
valuesWindow = self.__guessPositions(valuesWindow)
if valuesWindow.count() == 20:
for frameObjects in valuesWindow.get():
for obj in frameObjects:
if obj._saved != True:
query = "INSERT INTO %s(frame, seconds, milliseconds, x, y, velocity, accelaration, polygon, r, g, b, object) VALUES (%s,%f,%f,%s,%s,'%s', '%s','%s', %s, %s, %s, %s)" % (
tablename, obj._frame,
obj._milliseconds, obj._seconds,
obj._position[0], obj._position[1],
obj._velocity, obj._accelaration,
obj._blob, obj._r, obj._g, obj._b,
obj._label)
insertquery.exec_(query)
obj._saved = True
frame_values = [values]
else:
frame_values.append(values)
last_frame = frame
count += 1
self._progress.value = count
QApplication.processEvents()
for frameObjects in valuesWindow.get():
for obj in frameObjects:
if obj._saved != True:
query = "INSERT INTO %s(frame, seconds, milliseconds, x, y, velocity, accelaration, polygon, r, g, b, object) VALUES (%s,%f,%f,%s,%s,'%s', '%s','%s', %s, %s, %s, %s)" % (
tablename, obj._frame, obj._milliseconds,
obj._seconds, obj._position[0], obj._position[1],
obj._velocity, obj._accelaration, obj._blob,
obj._r, obj._g, obj._b, obj._label)
insertquery.exec_(query)
insertquery.exec_("CREATE INDEX Idx3 ON %s(object, new_object);" %
tablename)
insertquery.finish()
self._progress.value = totalResults
QApplication.processEvents()
self.parentModule.sqldb.commit()
self._progress.hide()
self._results.clearItems()
for label in range(self._nobjects.value):
self._results.addItem(
"%s" % label,
"SELECT id, frame, seconds, milliseconds, x, y, velocity, accelaration, object, r, g, b, object, new_object FROM %s WHERE object like %d"
% (tablename, label))
def getArenaIntersection(self, x, y, arenasDict):
for name, arena in arenasDict:
contour = array([eval(arena)], int32)
point = (x, y)
res = cv2.pointPolygonTest(contour, point, False)
if res >= 0:
return name
return "None"
class OTModuleAdaptativeThreshold(OTModulePlugin,OTModuleInputVideoPipe,OTPAdaptativeThreshold):
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTModuleInputVideoPipe.__init__(self)
OTPAdaptativeThreshold.__init__(self)
OTModulePlugin.__init__(self, name, iconFile=icon_path)
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video player")
#THRESHOLD
self._blockSize = OTParamSlider("Block size", 3, 3, 500,varname='_param_tb_block_size')
self._C = OTParamSlider("C", 0, 0, 500,varname='_param_tb_c')
self._adaptiveMethod = OTParamCombo("Adaptive method",varname='_param_tb_adaptive_method')
self._adaptiveMethod.addItem("Mean", cv2.cv.CV_ADAPTIVE_THRESH_MEAN_C)
self._adaptiveMethod.addItem("Gaussian", cv2.cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C)
self._th_colorDomain = OTParamCombo("Colors space",varname='_param_tb_color_domain')
self._th_colorDomain.addItem("RGB", -1)
self._th_colorDomain.addItem("Gray", cv2.COLOR_BGR2GRAY)
self._th_colorDomain.addItem("XYZ", cv2.COLOR_BGR2XYZ)
self._th_colorDomain.addItem("YCrCb", cv2.COLOR_BGR2YCR_CB)
self._th_colorDomain.addItem("HSV", cv2.COLOR_BGR2HSV)
self._th_colorDomain.addItem("HLS", cv2.COLOR_BGR2HLS)
self._th_colorDomain.addItem("Lab", cv2.COLOR_BGR2LAB)
self._th_colorDomain.addItem("Luv", cv2.COLOR_BGR2LUV)
self._colorComponent = OTParamCombo("Component",varname='_param_tb_color_component')
self._colorComponent.addItem("A", 0)
self._colorComponent.addItem("B", 1)
self._colorComponent.addItem("C", 2)
self._th_thresholdType = OTParamCombo("ThresholdType",varname='_param_tb_threshold_type')
self._th_thresholdType.addItem("THRESH_BINARY", cv2.THRESH_BINARY)
self._th_thresholdType.addItem("THRESH_BINARY_INV", cv2.THRESH_BINARY_INV)
#END THRESHOLD
self._th_colorDomain.valueUpdated = self.refreshValue
self._colorComponent.valueUpdated = self.refreshValue
self._adaptiveMethod.valueUpdated = self.refreshValue
self._blockSize.valueUpdated = self.refreshValue
self._C.valueUpdated = self.refreshValue
self._formset = [
'_video',"_player",
('_th_colorDomain','_colorComponent','_adaptiveMethod','_th_thresholdType'),
('_blockSize',"_C"),
]
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
def refreshValue(self, value): self._player.refresh()
def processFrame(self, frame):
result = self.compute(frame)
return result
def newVideoInputChoosen(self, value):
OTParamVideoInput.valueUpdated(self._video,value)
if value:
self.open(value)
self._player.value = value
def exportCodeTo(self, folder):
files_to_copy = []
classes, imports, constructer_params, parameters = [], [], [], []
#classes_tmp, imports_tmp, constructer_params_tmp, parameters_tmp = self._video.value.exportCodeTo(folder)
#classes += classes_tmp; imports += imports_tmp; constructer_params += constructer_params_tmp; parameters += parameters_tmp;
#SET OTPRemoveBackground
if self._removeBg.value:
classes_tmp, imports_tmp, constructer_params_tmp, parameters_tmp = self._background.value.exportCodeTo(folder)
classes += classes_tmp; imports += imports_tmp; constructer_params += constructer_params_tmp; parameters += parameters_tmp;
files_to_copy.append( 'OTPRemoveBackground' )
parameters.append("self._param_background_threshold = %d " % self._threshold.value )
#END SET
if self._useThreshold.value:
#SET OTPAdaptativeThreshold
files_to_copy.append( 'OTPAdaptativeThreshold' )
parameters.append("self._param_tb_color_component = %d " % self._colorComponent.value )
parameters.append("self._param_tb_color_domain = %d " % self._th_colorDomain.value )
parameters.append("self._param_tb_adaptive_method = %d " % self._adaptiveMethod.value )
parameters.append("self._param_tb_block_size = %d " % self._blockSize.value )
parameters.append("self._param_tb_threshold_type = %d " % self._th_thresholdType.value )
parameters.append("self._param_tb_c = %d " % self._C.value )
#END SET
elif self._useCanny.value:
#SET OTPCanny
files_to_copy.append( 'OTPCanny' )
parameters.append("self._param_canny_apertureSize = %d " % self._canny_apertureSize.value )
parameters.append("self._param_canny_L2gradient = %d " % self._canny_L2gradient.value )
parameters.append("self._param_canny_threshould1 = %d " % self._canny_threshould1.value )
parameters.append("self._param_canny_threshould2 = %d " % self._canny_threshould2.value )
parameters.append("self._param_canny_color_component = %d " % self._canny_colorComponent.value )
parameters.append("self._param_canny_color_domain = %d " % self._canny_colorDomain.value )
#END SET
else:
#SET OTPColorFilter
files_to_copy.append( 'OTPColorFilter' )
parameters.append("self._param_color_domain = %d " % self._colorDomain.value )
parameters.append("self._param_filter_algorithm = '%s' " % self._textAlgo.value )
parameters.append("self._param_a_min = %d " % self._minR.value )
parameters.append("self._param_a_max = %d " % self._maxR.value )
parameters.append("self._param_b_min = %d " % self._minG.value )
parameters.append("self._param_b_max = %d " % self._maxG.value )
parameters.append("self._param_c_min = %d " % self._minB.value )
parameters.append("self._param_c_max = %d " % self._maxB.value )
#END SET
#SET OTPBlur
if self._useBlur.value:
files_to_copy.append( 'OTPBlur' )
parameters.append("self._param_kernel_size = %d " % self._kernelSize.value )
parameters.append("self._param_blur_threshould = %d " % self._blurThreshold.value )
#END SET
#SET OTPMaskImage
if isinstance(self._video.value, OTModuleMaskFromGeometry):
files_to_copy.append( 'OTPMaskImage' )
parameters.append("self._param_mi_polygons = np.array(%s)" % str(self._video.value._all_polygons) )
imports.append("import numpy as np")
#END SET
#SET OTPFindBlobs
if self._exportFindBlobs.value:
files_to_copy.append( 'OTPFindBlobs' )
parameters.append("self._param_min_area = %d " % self._minArea.value )
parameters.append("self._param_max_area = %d " % self._maxArea.value )
#END SET
#SET OTPSelectBiggerBlobs
if self._selectBiggests.value:
files_to_copy.append( 'OTPSelectBiggerBlobs' )
parameters.append('self._param_n_blobs = %d' % self._howMany.value )
#END SET
classes += files_to_copy
for file_to_copy in files_to_copy:
filename = file_to_copy+".py"; originalfilepath = tools.getFileInSameDirectory(__file__, filename); destinyfilepath = os.path.join( folder, filename )
f = open(originalfilepath, 'r'); text = f.read(); f.close(); text = text.replace("from mcvgui.core.controllers.", "from "); f = open(destinyfilepath, 'w'); f.write(text); f.close()
imports.append( "from %s import %s" % (file_to_copy, file_to_copy) )
return classes, imports, constructer_params, parameters
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTPRemoveBackground.__init__(self)
OTPColorFilter.__init__(self)
OTPBlur.__init__(self)
OTPFindBlobs.__init__(self)
OTPSelectBiggerBlobs.__init__(self)
OTModuleResultsPlugin.__init__(self, name, iconFile=icon_path)
self._video = OTParamVideoInput("Video")
self._background = OTParamBackground("Background",
varname='_param_background')
self._threshold = OTParamSlider("Threshold",
110,
1,
255,
varname='_param_background_threshold')
self._minArea = OTParamSlider("Blob min. area",
100,
0,
50000,
varname='_param_min_area')
self._maxArea = OTParamSlider("Blob max. area",
10000,
0,
100000,
varname='_param_max_area')
self._textAlgo = OTParamText(
"Blob function ( Operations: [ AND: * ; OR: + ; SUB: - ; NEG: ~ ] Ex: A+B-~C )",
"A*B*C",
varname='_param_filter_algorithm')
self._removeBg = OTParamCheckBox("Remove the background", True)
self._editMode = OTParamCheckBox("Edit mode", True)
self._run = OTParamButton("Run")
self._player = OTParamPlayer("Video player")
self._progress = OTParamProgress()
self._selectBiggests = OTParamCheckBox(
"Select only the biggests blobs", True)
self._howMany = OTParamSlider("How many?",
1,
1,
20,
varname='_param_n_blobs')
self._useBlur = OTParamCheckBox("Use blur", True)
self._kernelSize = OTParamSlider("Kernel size",
1,
1,
50,
varname='_param_kernel_size')
self._blurThreshold = OTParamSlider("Blur threshold",
110,
1,
255,
varname='_param_blur_threshould')
self._colorDomain = OTParamCombo("Colors space",
varname='_param_color_domain')
self._colorDomain.addItem("RGB", -1)
self._colorDomain.addItem("XYZ", cv2.COLOR_BGR2XYZ)
self._colorDomain.addItem("YCrCb", cv2.COLOR_BGR2YCR_CB)
self._colorDomain.addItem("HSV", cv2.COLOR_BGR2HSV)
self._colorDomain.addItem("HLS", cv2.COLOR_BGR2HLS)
self._colorDomain.addItem("Lab", cv2.COLOR_BGR2LAB)
self._colorDomain.addItem("Luv", cv2.COLOR_BGR2LUV)
self._activeR = OTParamCheckBox("Active")
self._activeG = OTParamCheckBox("Active")
self._activeB = OTParamCheckBox("Active")
self._minR = OTParamSlider("min. A", 1, 0, 255, varname='_param_a_min')
self._maxR = OTParamSlider("max. A",
255,
0,
255,
varname='_param_a_max')
self._minG = OTParamSlider("min. B", 1, 0, 255, varname='_param_b_min')
self._maxG = OTParamSlider("max. B",
255,
0,
255,
varname='_param_b_max')
self._minB = OTParamSlider("min. C", 1, 0, 255, varname='_param_c_min')
self._maxB = OTParamSlider("max. C",
255,
0,
255,
varname='_param_c_max')
self._groupBlobs = OTParamCheckBox("Group blobs", True)
self._maxDistance = OTParamSlider("Max. dist. between blobs", 1, 30,
300)
self._groupBlobs.valueUpdated = self.groupBlobsUpdated
self._colorDomain.valueUpdated = self.refreshValue
self._activeR.valueUpdated = self.refreshValue
self._activeG.valueUpdated = self.refreshValue
self._activeB.valueUpdated = self.refreshValue
self._minR.valueUpdated = self.refreshValue
self._maxR.valueUpdated = self.refreshValue
self._minG.valueUpdated = self.refreshValue
self._maxG.valueUpdated = self.refreshValue
self._minB.valueUpdated = self.refreshValue
self._maxB.valueUpdated = self.refreshValue
self._textAlgo.valueUpdated = self.refreshValue
self._threshold.valueUpdated = self.refreshValue
self._kernelSize.valueUpdated = self.refreshValue
self._blurThreshold.valueUpdated = self.refreshValue
self._maxArea.valueUpdated = self.refreshValue
self._minArea.valueUpdated = self.refreshValue
self._maxDistance.valueUpdated = self.refreshValue
self._removeBg.valueUpdated = self.removeBgUpdate
self._useBlur.valueUpdated = self.useBlurUpdate
self._selectBiggests.valueUpdated = self.selectBiggestsUpdate
self._formset = [
('_video', '_editMode', '_run'),
[
"_player", {
"1. Filter colors": [
'_colorDomain', ("_minR", '_activeR', "_maxR"),
("_minG", '_activeG', "_maxG"),
("_minB", '_activeB', "_maxB"), "_textAlgo"
],
"2. Remove background":
['_removeBg', '_background', '_threshold'],
"3. Filter objects":
[('_minArea', '_maxArea'),
('_useBlur', '_kernelSize', '_blurThreshold'),
("_selectBiggests", "_howMany")],
"4. Tracking": [('_groupBlobs', '_maxDistance')],
}, "=", "_results", "_query"
], "_progress"
]
self._run.value = self.run
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
self._isRunning = False
self._blurThreshold.hide()
self._kernelSize.hide()
self._background.hide()
self._threshold.hide()
self._progress.hide()
self._howMany.hide()
self._results.hide()
self._query.hide()
self._maxDistance.hide()
class OTModuleAdjustPositions(OTModuleResultsPlugin, OTModulePositions):
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'icon.jpg')
OTModuleResultsPlugin.__init__(self, name, iconFile = icon_path)
self._x_col = 4 #Indicate the column with the X coord
self._y_col = 5 #Indicate the column with the Y coord
self._frame_col = 1 #Indicate the column with the Y coord
self._object_col = 6
self._current_row = None
self._imgWidth = 0.0
self._imgHeight = 0.0
self._startPoint = None
self._endPoint = None
self._video = OTParamVideoInput("Video")
self._positions = OTParamPositions("Positions")
self._showPos = OTParamCheckBox("Show position")
self._showTrack = OTParamCheckBox("Show track")
self._trackRange = OTParamSlider("Track range", 10, 10, 1000)
self._player = OTParamPlayer("Video player")
self._progress = OTParamProgress()
#Fields used to configure the Position draw function
self._show_draw_function = OTParamToggle("Show/Hide draw function")
self._draw_function = OTParamTextArea("Draw function", """def draw(frame, row):
x, y = int(row[self._x_col]), int(row[self._y_col])
cv2.circle(frame, (x, y), 3, (0,255,0), thickness=2, lineType= cv2.cv.CV_AA)""")
self._importFunc = OTParamButton("Import")
self._exportFunc = OTParamButton("Export")
#Fields used to configure the interpolation
self._columns = OTParamCheckBoxList("List of columns to interpolate")
self._run_interpolation = OTParamButton("Interpolate")
self._run_interpolation_4_all = OTParamButton("Interpolate")
#organization of the form
self._formset = [ ('_video','_positions'),
[ ('_columns', '_run_interpolation', '_run_interpolation_4_all'),
"_draw_function",
(" ", "_importFunc", "_exportFunc"),
"_player",
('_showPos',"_showTrack", "_trackRange")
,"=","_results", "_query"], '_progress' ]
self._trackRange.enabled = False
self._showPos.value = True
#setting up the fields events
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
self._positions.valueUpdated = self.newPositionsChoosen
self._showTrack.valueUpdated = self.showTrackToggle
self._query.selectionChanged = self.tableSelectionChanged
self._trackRange.valueUpdated = self.updateTrackRange
self._player._videoWidget.onEndDrag = self.onEndDragInVideoWindow
self._show_draw_function.value = self.showHideDrawFunction
self._importFunc.value = self.importFunction
self._exportFunc.value = self.exportFunction
self._run_interpolation.value = self.interpolationPositions
self._run_interpolation_4_all.value = self.interpolateAllPositions
#Hide fields
self._draw_function.hide()
self._progress.hide()
self._importFunc.hide()
self._exportFunc.hide()
self._columns.hide()
self._run_interpolation.hide()
self._run_interpolation_4_all.hide()
#Configure the popup menu
self._query.addPopupMenuOption("-")
self._query.addPopupSubMenuOption("Add", {"Interpolation": self.showColumns4Interpolation, "Duplicate row": self.addDuplicatedRow })
self._query.addPopupMenuOption("Remove", self._query.remove)
self._query.addPopupMenuOption("-")
self._query.addPopupMenuOption("Approximate all positions", self.approximatePositions)
self._query.addPopupMenuOption("Interpolate all positions", self.showColumns4InterpolationAll)
self._current_row_index = None #Variable used to read the current row when the video is playing
def onEndDragInVideoWindow(self, startPoint, endPoint, refresh=True):
self._startPoint = ( int(startPoint[0] * self._imgWidth), int(startPoint[1] * self._imgWidth) )
self._endPoint = ( int(endPoint[0] * self._imgWidth), int(endPoint[1] * self._imgWidth) )
current_row = self._query.mouseSelectedRow
if current_row!=None:
current_index = self._query.mouseSelectedRowIndex
current_frame = int(current_row[self._frame_col])
if (self._player.value.getCurrentFrame()) == current_frame:
x, y = int(current_row[self._x_col]), int(current_row[self._y_col])
#print "current_row", self._startPoint, x, y
if tools.pointsDistance( self._startPoint , (x,y) ) <= 10:
self._query.setValueIn( current_index, self._x_col, self._endPoint[0] )
self._query.setValueIn( current_index, self._y_col, self._endPoint[1] )
self._current_row = self._query.valuesInRow(current_index)
if refresh:
self._query.commit()
self._player.refresh()
self._query.refresh( current_index )
self._query.select()
def exportFunction(self):
filename = str(QFileDialog.getSaveFileName(self._form, 'Choose a file', '') )
if filename!="":
output = open( filename, 'wb')
pickle.dump( self._draw_function.value , output)
output.close()
def importFunction(self):
filename = str(QFileDialog.getOpenFileName(self._form, 'Choose a file', '') )
if filename!="":
pkl_file = open( filename, 'rb'); data = pickle.load(pkl_file); pkl_file.close()
self._draw_function.value = data
func = self._draw_function.value
exec func
self.drawRow = draw
def showHideDrawFunction(self, value):
if value:
self._player.hide()
self._importFunc.show()
self._exportFunc.show()
self._draw_function.show()
else:
self._draw_function.hide()
self._importFunc.hide()
self._exportFunc.hide()
self._player.show()
func = self._draw_function.value
#code = compile(func, '<string>', 'exec')
exec func
self.drawRow = draw
"""d = {}
exec func.strip() in d
print d
setattr(self.__class__, 'drawRow', d['drawRow'])
"""
#self.drawRow = eval( func)
def approximatePositions(self):
totalCountRows = self._query.count
firstRow = self._query.valuesInRow( totalCountRows-1 )
firstPoint = ( int(firstRow[self._x_col]), int(firstRow[self._y_col]) )
lastAngle = None
self._progress.show()
self._progress.min = 0
self._progress.value = 0
self._progress.max = totalCountRows
query = QSqlQuery( self.parentModule.sqldb )
self._query.beginTransaction()
for i in range( totalCountRows-2, 0, -1 ): #print i
currentRow = self._query.valuesInRow( i )
currentPoint = ( int(currentRow[self._x_col]), int(currentRow[self._y_col]) )
dist = tools.pointsDistance( firstPoint, currentPoint )
vector = ( firstPoint[0]-currentPoint[0], firstPoint[1]-currentPoint[1] )
angle = math.atan2( vector[1], vector[0] )
angleInDegrees = math.degrees( angle )
frame = currentRow[self._frame_col]
obj = currentRow[self._object_col]
#print "angle:---", angleInDegrees, lastAngle
if lastAngle==None: lastAngle=angleInDegrees
if dist<=10:
#self._query.removeRow( i )
#print "DELETE FROM %s WHERE frame='%s' and object='%s' " % (self._query.table, frame, obj )
query.exec_("DELETE FROM %s WHERE frame='%s' and object='%s' " % (self._query.table, frame, obj ) )
elif( math.fabs(lastAngle-angleInDegrees)>=5 ):
#print "angles", angleInDegrees, lastAngle
firstPoint = currentPoint
lastAngle = angleInDegrees
else:
#print "DELETE FROM %s WHERE frame='%s' and object='%s' " % (self._query.table, frame, obj )
query.exec_("DELETE FROM %s WHERE frame='%s' and object='%s' " % (self._query.table, frame, obj ) )
#self._query.removeRow( i )
self._progress.value = totalCountRows - i
QApplication.processEvents()
self._query.commit()
self._progress.hide()
self._query.refresh(0)
def showTrackToggle(self, value):
self._trackRange.enabled = value
def updateTrackRange(self, value):
if isinstance(self._player.value, OTVideoInput): self._player.refresh()
############################################################################
############ Parent class functions reemplementation #######################
############################################################################
def selectionChanged(self, selected, deselected):
"""
Redefinition of the function selectionChanged from OTModuleResultsPlugin
"""
QTableView.selectionChanged(self._query.form.tableView, selected, deselected)
row = self._query.mouseSelectedRow
if row != None:
self._current_row = row
video = self._video.value
frame_index = int( row[self._frame_col] )
video.videoInput.setFrame( frame_index-1 )
self._player.updateFrame()
############################################################################
############ Events ########################################################
############################################################################
def updateProgressBar(self, index): self._progress.value = index
def interpolateAllPositions(self):
"""
Event called when user click in interpolation button
"""
self._run_interpolation.hide()
self._run_interpolation_4_all.hide()
self._columns.hide()
self._player.show()
totalCountRows = self._query.count
n_columns = len(self._query.columns)
checked_columns = self._columns.checkedIndexes
cols_2_interpolate = map( lambda x: True if x in checked_columns else False, range(n_columns) )
self._progress.show()
self._progress.min = 0
self._progress.value = 0
self._progress.max = totalCountRows
for i in range( 0, totalCountRows-1 ):
self.interpolateBetween2Rows( i, i+1, update = self.updateProgressBar ,cols_2_interpolate = cols_2_interpolate )
self._query.commit()
self._progress.value = i
self._progress.hide()
self._query.orderBy = 1
def interpolationPositions(self):
"""
Event called when user click in interpolation button
"""
self._run_interpolation.hide()
self._run_interpolation_4_all.hide()
self._columns.hide()
self._player.show()
rowsIndexes = self._query.mouseSelectedRowsIndexes
rowsIndexes.sort()
if len(rowsIndexes)==2 and rowsIndexes[0]==rowsIndexes[1]-1: #check is the rows are consecutives
rows = self._query.mouseSelectedRows
diff = float(abs( int(rows[1][0]) - int(rows[0][0]) ))
if diff > 1 :
print rowsIndexes[0], rowsIndexes[1]
self.interpolateBetween2Rows( rowsIndexes[0], rowsIndexes[1], update = self.updateProgressBar )
self._query.commit()
self._query.orderBy = 1
self._query.mouseSelectedRowsIndexes = rowsIndexes[0]
else:
QMessageBox. warning(self._form, 'Warning', "Is not possible to add more frames between the selected ones")
else:
QMessageBox. warning(self._form, 'Warning', "You should select two consecutive rows")
def addDuplicatedRow(self):
"""
Event called when a user click on the popup menu option
"""
rows = self._query.mouseSelectedRows
rowsIndexes = self._query.mouseSelectedRowsIndexes
if len(rows)==1:
lastRow = rows[-1]
self._query.addRow(lastRow, rowsIndexes[0])
else:
QMessageBox. warning(self._control, 'Warning', "You should select one row to duplicate")
self._query.orderBy = 1
self._query.mouseSelectedRowsIndexes = rowsIndexes[0]
def showColumns4Interpolation(self):
"""
Event called when a user click on the popup menu option
"""
self._player.hide()
self._draw_function.hide()
self._exportFunc.hide()
self._importFunc.hide()
self._run_interpolation_4_all.hide()
self._columns.show()
self._run_interpolation.show()
def showColumns4InterpolationAll(self):
"""
Event called when a user click on the popup menu option
"""
self._player.hide()
self._draw_function.hide()
self._exportFunc.hide()
self._importFunc.hide()
self._run_interpolation.hide()
self._columns.show()
self._run_interpolation_4_all.show()
def tableSelectionChanged(self):
"""
Event called when a user select rows using the popup menu
"""
self._player.refresh()
def newVideoInputChoosen(self, value):
"""
Event called when a user select rows using the popup menu
@param value: Video module
@type value: OTModule
"""
OTParamVideoInput.valueUpdated(self._video,value)
if value.videoInput:
value.videoInput.setFrame(0)
self._player.value = value.videoInput
self._imgWidth = float(value.videoInput.width)
self._imgHeight = float(value.videoInput.height)
self._trackRange.max = value.videoInput.endFrame-value.videoInput.startFrame
def newPositionsChoosen(self, value):
"""
Event called when a new dataset of Positions is choosen
@param frame: Frame that would be showed
@type frame: Numpy array
"""
if value:
items = value._results.values
self._results.clearItems()
for key, sql in items: self._results.addItem(key, sql)
self._columns.clear()
list_of_columns = self._query.columns
self._columns.value = map(lambda x: (x, False), list_of_columns)
self._x_col = self._query.columnIndex("x")
self._y_col = self._query.columnIndex("y")
self._frame_col = self._query.columnIndex("frame")
def processFrame(self, frame, drawSelectedRows = True):
"""
This is an event called by the player before he shows the video frame
@param frame: Frame that would be showed
@type frame: Numpy array
"""
#Draw the path of the rat
if self._showTrack.value:
row_index = self._query.mouseSelectedRowIndex
if row_index!=None:
points = []
for row in range(row_index, row_index + self._trackRange.value):
values = self._query.valuesInRow(row)
if values!= None:
x = int(values[self._x_col])
y = int(values[self._y_col])
points.append( (x,y) )
if len(points)>0: cv2.polylines( frame , [array(points,int32)] , False, (255,255,0), 1, lineType=cv2.cv.CV_AA )
#draw the selected path
#When the rows are selected with the popup menu in the Table
if drawSelectedRows:
selectedRows = self._query.selectedRows
if len( selectedRows )>0:
track_points = []
for row in selectedRows:
values = self._query.valuesInRow(row)
x = int(values[self._x_col])
y = int(values[self._y_col])
track_points.append( (x,y) )
cv2.polylines(frame, [array(track_points,int32)], False, (0,255,0), 1)
for point in track_points: cv2.circle(frame, point, 3, (0,0,255), thickness=1, lineType= cv2.cv.CV_AA)
#Draw the current mouse selected row
if self._current_row != None and self._showPos.value: frame = self.drawRow( frame, self._current_row, (0,0,255) )
if self._player.is_playing(): self.drawCurrentPositionWhenIsPlaying(frame)
return frame
############################################################################
############ Functions #####################################################
############################################################################
def search_4_frame(self, frame2Search, startAtRow = 0):
"""
This function search for a frame in the List _query
@param frame2Search: Frame to search
@type frame2Search: Integer
@param startAtRow: Start looking in the List row index
@type startAtRow: Integer
"""
if startAtRow<0: startAtRow=0
total_count_rows = self._query.count
if total_count_rows==0: # No rows
return None
elif total_count_rows==1: #If only one row
unique_row = self._query.valuesInRow( 0 )
frame = int(unique_row[self._frame_col])
if frame > frame2Search: return 0, None, unique_row, None
else: return None, 0, None, unique_row
elif startAtRow >= total_count_rows: # In case of start searching in a non existing row
last_row = self._query.valuesInRow( total_count_rows-1 )
return total_count_rows-1, None, last_row, None
else:
#check the next row
previous_row = self._query.valuesInRow( startAtRow )
next_row = self._query.valuesInRow( startAtRow + 1 )
if previous_row!=None and next_row!=None: #check the current row
previous_frame = int(previous_row[self._frame_col])
next_frame = int(next_row[self._frame_col])
if previous_frame<=frame2Search<next_frame:
return startAtRow, startAtRow+1, previous_row, next_row
else: #check the next row
previous_row = self._query.valuesInRow( startAtRow+1 )
next_row = self._query.valuesInRow( startAtRow+2 )
if previous_row!=None and next_row!=None:
previous_frame = int(previous_row[self._frame_col])
next_frame = int(next_row[self._frame_col])
if previous_frame<=frame2Search<next_frame:
return startAtRow+1, startAtRow+2, previous_row, next_row
#check if the frame to search is bellow the first row and higher than the last frame
first_row = self._query.valuesInRow( 0 )
first_frame = int(first_row[self._frame_col])
last_row = self._query.valuesInRow( total_count_rows-1 )
last_frame = int(last_row[self._frame_col])
if first_frame>=frame2Search:
return None, 0, None, first_row
elif frame2Search>=last_frame:
return total_count_rows-1, None, last_row, None
else:
#Give up!!!! ....Start a binary tree search
previous_row_index = 0
next_row_index = (total_count_rows+1)/2
count = 0
# search for the frame
calculateSize = True
while True:
if count > 10000: # for security. We don't want the algorithm to enter in a infinite loop
return None
if calculateSize: sizeOfList2Search = (next_row_index - previous_row_index)
calculateSize = True
next_row = self._query.valuesInRow( next_row_index )
next_frame = int( next_row[self._frame_col] )
previous_row = self._query.valuesInRow( previous_row_index )
previous_frame = int( previous_row[self._frame_col] )
if sizeOfList2Search==1 and previous_frame <= frame2Search < next_frame:
return previous_row_index, next_row_index, previous_row, next_row
elif sizeOfList2Search<1:
return None
elif previous_frame==frame2Search:
return previous_row_index, previous_row_index+1, previous_row, self._query.valuesInRow( previous_row_index+1 )
elif next_frame <= frame2Search and sizeOfList2Search>1:
previous_row_index = next_row_index
next_row_index += (sizeOfList2Search+1)/2
if next_row_index>=total_count_rows: next_row_index = total_count_rows-1
elif previous_frame < frame2Search < next_frame and sizeOfList2Search>1:
next_row_index -= (sizeOfList2Search+1)/2
if next_row_index<0: next_row_index = previous_row_index+1
calculateSize = False
else:
count += 1
def drawCurrentPositionWhenIsPlaying( self, frame ):
current_frame = self._player.value.getCurrentFrame()
res = self.search_4_frame( current_frame, self._current_row_index )
if res!=None and self._showPos.value:
previous_index, next_index, previous_row, next_row = res
row = None
if previous_row==None:
self._current_row_index = 0
row = next_row
x, y = int(row[self._x_col]), int(row[self._y_col])
elif next_row==None:
self._current_row_index = previous_index
row = previous_row
x, y = int(row[self._x_col]), int(row[self._y_col])
else:
row = previous_row
prev_x, prev_y = float(previous_row[self._x_col]), float(previous_row[self._y_col])
next_x, next_y = float(next_row[self._x_col]), float(next_row[self._y_col])
prev_frame, next_frame = int(previous_row[0]), int(next_row[0])
nSteps = float(next_frame - prev_frame)
xStep, yStep = (next_x-prev_x)/nSteps, (next_y-prev_y)/nSteps
nSteps2CurrentFrame = float(current_frame-prev_frame)
x, y = xStep*nSteps2CurrentFrame, yStep*nSteps2CurrentFrame
x, y = int(round( prev_x + x )), int(round( prev_y + y ))
#row[self._x_col], row[self._y_col] = x, y
#frame = self.drawRow( frame, row, (255,0,0) )
cv2.circle(frame, (x,y), 3, (255,0,0), 2)
return frame
def drawRow(self, frame, row, color = (0,255,0) ):
x, y = int(row[self._x_col]), int(row[self._y_col])
cv2.circle(frame, (x, y), 3, color, thickness=2, lineType= cv2.cv.CV_AA)
return frame
def interpolateBetween2Rows(self, row1, row2, update = (lambda x: 0), cols_2_interpolate = None ):
"""
Interpolate values between 2 rows
@param row1: First row
@type row1: Integer
@param row2: First row
@type row2: Integer
"""
if cols_2_interpolate==None:
checked_columns = self._columns.checkedIndexes
n_columns = len(self._query.columns)
cols_2_interpolate = map( lambda x: True if x in checked_columns else False, range(n_columns) )
else:
n_columns = len(cols_2_interpolate)
previous_row = self._query.valuesInRow( row1 )
next_row = self._query.valuesInRow( row2 )
previous_frame = int( previous_row[self._frame_col] )
next_frame = int( next_row[self._frame_col] )
diff_frames = float( next_frame - previous_frame )
if diff_frames>1:
previous, next, diff, step = [], [], [], []
for i in range(n_columns):
if cols_2_interpolate[i]:
previous.append( float(previous_row[i]) )
next.append( float(next_row[i]) )
diff = float(next[i]) - float(previous[i])
step.append( diff / diff_frames )
else:
step.append( None )
previous.append( previous_row[i] )
next.append( next_row[i] )
for j in range(1, int(diff_frames)):
values = []
for i in range(n_columns):
if cols_2_interpolate[i]:
if int(previous[i])==previous[i] and int(next[i])==next[i]:
val = int(previous[i]) + int(round( step[i]* float(j) ))
else:
val = previous[i] + step[i]*float(j)
else: val = previous[i]
values.append( val )
update( row1 + j )
values.pop(0)
self._query.addRow( values, -1,cols= [ 'frame', 'seconds','milliseconds', 'x', 'y', 'object' ])
QApplication.processEvents()
class OTModuleSubBackground(OTModuleResultsPlugin, OTModulePositions,
OTPRemoveBackground, OTPColorFilter, OTPBlur,
OTPFindBlobs, OTPSelectBiggerBlobs):
MHI_DURATION = 0.5
MAX_TIME_DELTA = 0.25
MIN_TIME_DELTA = 0.05
_isRunning = None
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTPRemoveBackground.__init__(self)
OTPColorFilter.__init__(self)
OTPBlur.__init__(self)
OTPFindBlobs.__init__(self)
OTPSelectBiggerBlobs.__init__(self)
OTModuleResultsPlugin.__init__(self, name, iconFile=icon_path)
self._video = OTParamVideoInput("Video")
self._background = OTParamBackground("Background",
varname='_param_background')
self._threshold = OTParamSlider("Threshold",
110,
1,
255,
varname='_param_background_threshold')
self._minArea = OTParamSlider("Blob min. area",
100,
0,
50000,
varname='_param_min_area')
self._maxArea = OTParamSlider("Blob max. area",
10000,
0,
100000,
varname='_param_max_area')
self._textAlgo = OTParamText(
"Blob function ( Operations: [ AND: * ; OR: + ; SUB: - ; NEG: ~ ] Ex: A+B-~C )",
"A*B*C",
varname='_param_filter_algorithm')
self._removeBg = OTParamCheckBox("Remove the background", True)
self._editMode = OTParamCheckBox("Edit mode", True)
self._run = OTParamButton("Run")
self._player = OTParamPlayer("Video player")
self._progress = OTParamProgress()
self._selectBiggests = OTParamCheckBox(
"Select only the biggests blobs", True)
self._howMany = OTParamSlider("How many?",
1,
1,
20,
varname='_param_n_blobs')
self._useBlur = OTParamCheckBox("Use blur", True)
self._kernelSize = OTParamSlider("Kernel size",
1,
1,
50,
varname='_param_kernel_size')
self._blurThreshold = OTParamSlider("Blur threshold",
110,
1,
255,
varname='_param_blur_threshould')
self._colorDomain = OTParamCombo("Colors space",
varname='_param_color_domain')
self._colorDomain.addItem("RGB", -1)
self._colorDomain.addItem("XYZ", cv2.COLOR_BGR2XYZ)
self._colorDomain.addItem("YCrCb", cv2.COLOR_BGR2YCR_CB)
self._colorDomain.addItem("HSV", cv2.COLOR_BGR2HSV)
self._colorDomain.addItem("HLS", cv2.COLOR_BGR2HLS)
self._colorDomain.addItem("Lab", cv2.COLOR_BGR2LAB)
self._colorDomain.addItem("Luv", cv2.COLOR_BGR2LUV)
self._activeR = OTParamCheckBox("Active")
self._activeG = OTParamCheckBox("Active")
self._activeB = OTParamCheckBox("Active")
self._minR = OTParamSlider("min. A", 1, 0, 255, varname='_param_a_min')
self._maxR = OTParamSlider("max. A",
255,
0,
255,
varname='_param_a_max')
self._minG = OTParamSlider("min. B", 1, 0, 255, varname='_param_b_min')
self._maxG = OTParamSlider("max. B",
255,
0,
255,
varname='_param_b_max')
self._minB = OTParamSlider("min. C", 1, 0, 255, varname='_param_c_min')
self._maxB = OTParamSlider("max. C",
255,
0,
255,
varname='_param_c_max')
self._groupBlobs = OTParamCheckBox("Group blobs", True)
self._maxDistance = OTParamSlider("Max. dist. between blobs", 1, 30,
300)
self._groupBlobs.valueUpdated = self.groupBlobsUpdated
self._colorDomain.valueUpdated = self.refreshValue
self._activeR.valueUpdated = self.refreshValue
self._activeG.valueUpdated = self.refreshValue
self._activeB.valueUpdated = self.refreshValue
self._minR.valueUpdated = self.refreshValue
self._maxR.valueUpdated = self.refreshValue
self._minG.valueUpdated = self.refreshValue
self._maxG.valueUpdated = self.refreshValue
self._minB.valueUpdated = self.refreshValue
self._maxB.valueUpdated = self.refreshValue
self._textAlgo.valueUpdated = self.refreshValue
self._threshold.valueUpdated = self.refreshValue
self._kernelSize.valueUpdated = self.refreshValue
self._blurThreshold.valueUpdated = self.refreshValue
self._maxArea.valueUpdated = self.refreshValue
self._minArea.valueUpdated = self.refreshValue
self._maxDistance.valueUpdated = self.refreshValue
self._removeBg.valueUpdated = self.removeBgUpdate
self._useBlur.valueUpdated = self.useBlurUpdate
self._selectBiggests.valueUpdated = self.selectBiggestsUpdate
self._formset = [
('_video', '_editMode', '_run'),
[
"_player", {
"1. Filter colors": [
'_colorDomain', ("_minR", '_activeR', "_maxR"),
("_minG", '_activeG', "_maxG"),
("_minB", '_activeB', "_maxB"), "_textAlgo"
],
"2. Remove background":
['_removeBg', '_background', '_threshold'],
"3. Filter objects":
[('_minArea', '_maxArea'),
('_useBlur', '_kernelSize', '_blurThreshold'),
("_selectBiggests", "_howMany")],
"4. Tracking": [('_groupBlobs', '_maxDistance')],
}, "=", "_results", "_query"
], "_progress"
]
self._run.value = self.run
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
self._isRunning = False
self._blurThreshold.hide()
self._kernelSize.hide()
self._background.hide()
self._threshold.hide()
self._progress.hide()
self._howMany.hide()
self._results.hide()
self._query.hide()
self._maxDistance.hide()
def refreshValue(self, value):
self._player.refresh()
def groupBlobsUpdated(self, value):
if value:
self._maxDistance.show()
else:
self._maxDistance.hide()
self._player.refresh()
def selectBiggestsUpdate(self, value):
if value:
self._howMany.show()
else:
self._howMany.hide()
self._player.refresh()
def useBlurUpdate(self, value):
if value:
self._kernelSize.show()
self._blurThreshold.show()
else:
self._kernelSize.hide()
self._blurThreshold.hide()
self._player.refresh()
def removeBgUpdate(self, value):
if value:
self._background.show()
self._threshold.show()
else:
self._background.hide()
self._threshold.hide()
self._player.refresh()
def run(self):
if self._isRunning == True:
self._isRunning = False
else:
self._run.label = "Cancel"
self._isRunning = True
video = self._video.value
self._player.enabled = False
self._query.enabled = False
self._results.enabled = False
self._minArea.enabled = False
self._maxArea.enabled = False
self._video.enabled = False
self._background.enabled = False
self._editMode.enabled = False
self._colorDomain.enabled = False
self._activeR.enabled = False
self._activeG.enabled = False
self._activeB.enabled = False
self._minR.enabled = False
self._maxR.enabled = False
self._minG.enabled = False
self._maxG.enabled = False
self._minB.enabled = False
self._maxB.enabled = False
self._progress.show()
self._progress.min = video.videoInput.startFrame
self._progress.value = video.videoInput.startFrame
self._progress.max = video.videoInput.endFrame
QApplication.processEvents()
query = QtSql.QSqlQuery(self.parentModule.sqldb)
query.exec_("PRAGMA cache_size = 65536")
query.exec_("PRAGMA temp_store = MEMORY")
query.exec_("PRAGMA journal_mode = OFF")
#query.exec_("PRAGMA locking_mode = EXCLUSIVE")
query.exec_("PRAGMA synchronous = OFF")
tablename = "%s_output" % (self.name.replace(
" ", "").lstrip('0123456789.'))
res = query.exec_("DROP TABLE IF EXISTS %s" % tablename)
if not res:
print "trying to drop: ", query.lastError().text()
query.finish()
query = QtSql.QSqlQuery(self.parentModule.sqldb)
query.exec_("PRAGMA cache_size = 65536")
query.exec_("PRAGMA temp_store = MEMORY")
query.exec_("PRAGMA journal_mode = OFF")
query.exec_("PRAGMA synchronous = OFF")
res = query.exec_("DELETE FROM %s" % tablename)
if not res:
print "trying to delete: ", query.lastError().text()
self.parentModule.sqldb.commit()
else:
query.exec_(
"CREATE TABLE if not exists %s(id INTEGER PRIMARY KEY AUTOINCREMENT, frame BIGINT, seconds DOUBLE, milliseconds BIGINT, x INTEGER, y INTEGER, polygon text, b INTEGER, g INTEGER, r INTEGER)"
% tablename)
success = True
video.videoInput.setFrame(0)
while (success and self._isRunning):
(success, frame) = video.videoInput.read()
if success:
self.processFrame(frame)
milliseconds = video.videoInput.getCurrentFrame(
) * video.videoInput.videoFrameTimeInterval
for i, obj in enumerate(self._objectsFound):
centroid = obj._centroid
poly = obj._contour.tolist(
) #cv2.convexHull(obj['countour']).tolist()
b_avg = obj._b_avg
g_avg = obj._g_avg
r_avg = obj._r_avg
query.exec_(
"INSERT INTO %s( frame, seconds, milliseconds, x, y, polygon, b,g,r ) VALUES (%d,%f,%f,%d,%d,'%s', %d, %d, %d)"
%
(tablename, video.videoInput.getCurrentFrame(),
milliseconds / 1000.0, milliseconds, centroid[0],
centroid[1], poly, b_avg, g_avg, r_avg))
self._progress.value = video.videoInput.getCurrentFrame()
QApplication.processEvents()
self._progress.value = video.videoInput.endFrame
QApplication.processEvents()
query.finish()
self.parentModule.sqldb.commit()
self._progress.hide()
self._player.enabled = True
self._query.enabled = True
self._results.enabled = True
self._minArea.enabled = True
self._maxArea.enabled = True
self._video.enabled = True
self._background.enabled = True
self._editMode.enabled = True
self._colorDomain.enabled = True
self._activeR.enabled = True
self._activeG.enabled = True
self._activeB.enabled = True
self._minR.enabled = True
self._maxR.enabled = True
self._minG.enabled = True
self._maxG.enabled = True
self._minB.enabled = True
self._maxB.enabled = True
self._isRunning = False
self._run.label = "Run"
self._results.clearItems()
self._results.addItem(
"Results",
"SELECT id, frame, seconds, milliseconds, x, y, polygon, b,g,r FROM %s"
% tablename)
self._results.show()
self._query.show()
def newVideoInputChoosen(self, value):
OTParamVideoInput.valueUpdated(self._video, value)
if value.videoInput:
self._player.value = value.videoInput
value.videoInput.setFrame(0)
def __calcObjectsDist(self, obj, objects_list):
results = []
for x in objects_list:
dist = tools.pointsDistance(obj._centroid, x._centroid)
results.append((dist, x))
return sorted(results, key=lambda x: x[0], reverse=True)
def processFrame(self, frame):
original = frame.copy()
if self._removeBg.value:
frame = OTPRemoveBackground.process(self, frame)
fish = OTPColorFilter.process(self, frame)
if self._useBlur.value: fish = OTPBlur.process(self, fish)
self._objectsFound = OTPFindBlobs.process(self, fish)
for obj in self._objectsFound:
mask = zeros_like(original)
cv2.fillPoly(mask, obj._contour, (255, 255, 255))
res = cv2.bitwise_and(original, mask)
b, g, r = cv2.split(res)
b_avg = mean(b[b > 0])
g_avg = mean(g[g > 0])
r_avg = mean(r[r > 0])
obj._color = b_avg, g_avg, r_avg
if self._selectBiggests.value:
self._objectsFound = OTPSelectBiggerBlobs.process(
self, self._objectsFound)
################################################################
################################################################
contours2Display = []
for obj in self._objectsFound:
contours2Display.append(obj._contour)
if self._editMode.value:
cv2.drawContours(frame, array(contours2Display), -1, (0, 255, 0),
2)
else:
cv2.drawContours(frame, array(contours2Display), -1, (0, 255, 0),
2)
for i, obj in enumerate(self._objectsFound):
cv2.circle(frame, obj._centroid, 5, (255, 0, 0), thickness=1)
p = obj._bounding[0]
text = "AREA: %d" % obj._area
cv2.putText(frame, text, p, cv2.FONT_HERSHEY_SIMPLEX, 0.3,
(255, 255, 255), 3)
cv2.putText(frame, text, p, cv2.FONT_HERSHEY_SIMPLEX, 0.3,
(0, 0, 255), 1)
if self._editMode.value:
if self._colorDomain.value >= 0:
original = cv2.cvtColor(original, self._colorDomain.value)
r, g, b = cv2.split(original)
if not self._activeR.value: r = r * 0
if not self._activeG.value: g = g * 0
if not self._activeB.value: b = b * 0
r = cv2.inRange(r, array(self._minR.value),
array(self._maxR.value))
g = cv2.inRange(g, array(self._minG.value),
array(self._maxG.value))
b = cv2.inRange(b, array(self._minB.value),
array(self._maxB.value))
image = cv2.merge((b, g, r))
return [frame, image, fish]
else:
return frame
def exportCodeTo(self, folder):
files_to_copy = []
files_to_include = []
constructor = ""
parameters = []
imports = ""
files, imp, cons, params = self._video.value.exportCodeTo(folder)
constructor += cons
parameters += params
imports += imp
files_to_include += files
print files_to_include, files
if self._removeBg.value:
files, imp, cons, params = self._background.value.exportCodeTo(
folder)
constructor += cons
parameters += params
files_to_copy.append("OTPRemoveBackground")
imports += imp
files_to_include += files
parameters.append("self._param_background_threshold = %d " %
self._threshold.value)
files_to_copy.append("OTPColorFilter")
parameters.append("self._param_color_domain = %d " %
self._colorDomain.value)
parameters.append("self._param_filter_algorithm = '%s' " %
self._textAlgo.value)
parameters.append("self._param_a_min = %d " % self._minR.value)
parameters.append("self._param_a_max = %d " % self._maxR.value)
parameters.append("self._param_b_min = %d " % self._minG.value)
parameters.append("self._param_b_max = %d " % self._maxG.value)
parameters.append("self._param_c_min = %d " % self._minB.value)
parameters.append("self._param_c_max = %d " % self._maxB.value)
if self._useBlur.value:
files_to_copy.append("OTPBlur")
parameters.append("self._param_kernel_size = %d " %
self._kernelSize.value)
parameters.append("self._param_blur_threshould = %d " %
self._blurThreshold.value)
self._objectsFound = files_to_copy.append("OTPFindBlobs")
parameters.append("self._param_min_area = %d " % self._minArea.value)
parameters.append("self._param_max_area = %d " % self._maxArea.value)
if self._selectBiggests.value:
files_to_copy.append("OTPSelectBiggerBlobs")
parameters.append("self._param_n_blobs = %d " %
self._howMany.value)
for file_to_copy in files_to_copy:
filename = file_to_copy + ".py"
originalfilepath = tools.getFileInSameDirectory(__file__, filename)
destinyfilepath = os.path.join(folder, filename)
#shutil.copy2(originalfilepath,destinyfilepath)
f = open(originalfilepath, 'r')
text = f.read()
f.close()
text = text.replace("from mcvgui.core.controllers.", "from ")
f = open(destinyfilepath, 'w')
f.write(text)
f.close()
imports += "from %s import %s \n" % (file_to_copy, file_to_copy)
files_to_include += files_to_copy
files_to_include.reverse()
return files_to_include, imports, constructor, parameters
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'icon.jpg')
OTModuleResultsPlugin.__init__(self, name, iconFile = icon_path)
self._x_col = 4 #Indicate the column with the X coord
self._y_col = 5 #Indicate the column with the Y coord
self._frame_col = 1 #Indicate the column with the Y coord
self._object_col = 6
self._current_row = None
self._imgWidth = 0.0
self._imgHeight = 0.0
self._startPoint = None
self._endPoint = None
self._video = OTParamVideoInput("Video")
self._positions = OTParamPositions("Positions")
self._showPos = OTParamCheckBox("Show position")
self._showTrack = OTParamCheckBox("Show track")
self._trackRange = OTParamSlider("Track range", 10, 10, 1000)
self._player = OTParamPlayer("Video player")
self._progress = OTParamProgress()
#Fields used to configure the Position draw function
self._show_draw_function = OTParamToggle("Show/Hide draw function")
self._draw_function = OTParamTextArea("Draw function", """def draw(frame, row):
x, y = int(row[self._x_col]), int(row[self._y_col])
cv2.circle(frame, (x, y), 3, (0,255,0), thickness=2, lineType= cv2.cv.CV_AA)""")
self._importFunc = OTParamButton("Import")
self._exportFunc = OTParamButton("Export")
#Fields used to configure the interpolation
self._columns = OTParamCheckBoxList("List of columns to interpolate")
self._run_interpolation = OTParamButton("Interpolate")
self._run_interpolation_4_all = OTParamButton("Interpolate")
#organization of the form
self._formset = [ ('_video','_positions'),
[ ('_columns', '_run_interpolation', '_run_interpolation_4_all'),
"_draw_function",
(" ", "_importFunc", "_exportFunc"),
"_player",
('_showPos',"_showTrack", "_trackRange")
,"=","_results", "_query"], '_progress' ]
self._trackRange.enabled = False
self._showPos.value = True
#setting up the fields events
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
self._positions.valueUpdated = self.newPositionsChoosen
self._showTrack.valueUpdated = self.showTrackToggle
self._query.selectionChanged = self.tableSelectionChanged
self._trackRange.valueUpdated = self.updateTrackRange
self._player._videoWidget.onEndDrag = self.onEndDragInVideoWindow
self._show_draw_function.value = self.showHideDrawFunction
self._importFunc.value = self.importFunction
self._exportFunc.value = self.exportFunction
self._run_interpolation.value = self.interpolationPositions
self._run_interpolation_4_all.value = self.interpolateAllPositions
#Hide fields
self._draw_function.hide()
self._progress.hide()
self._importFunc.hide()
self._exportFunc.hide()
self._columns.hide()
self._run_interpolation.hide()
self._run_interpolation_4_all.hide()
#Configure the popup menu
self._query.addPopupMenuOption("-")
self._query.addPopupSubMenuOption("Add", {"Interpolation": self.showColumns4Interpolation, "Duplicate row": self.addDuplicatedRow })
self._query.addPopupMenuOption("Remove", self._query.remove)
self._query.addPopupMenuOption("-")
self._query.addPopupMenuOption("Approximate all positions", self.approximatePositions)
self._query.addPopupMenuOption("Interpolate all positions", self.showColumns4InterpolationAll)
self._current_row_index = None #Variable used to read the current row when the video is playing
class OTModuleBlobsFilter(OTModulePlugin,OTModulePositions, OTPThreshBlobs, OTPThreshImage):
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTModulePlugin.__init__(self, name, iconFile=icon_path)
OTPThreshImage.__init__(self)
OTPThreshBlobs.__init__(self)
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video player")
self._polygons = OTParamGeometry("Geometry")
self._blockSize = OTParamSlider("Block size", 3, 3, 500,varname='_param_tb_block_size')
self._C = OTParamSlider("C", 0, 0, 500,varname='_param_tb_c')
self._boxWidth = OTParamSlider("Width", 0, 0, 30,varname='_param_tb_box_width')
self._boxHeight = OTParamSlider("Height", 0, 0, 30,varname='_param_tb_box_height')
self._adaptiveMethod = OTParamCombo("Adaptive method",varname='_param_tb_adaptive_method')
self._adaptiveMethod.addItem("Mean", cv2.cv.CV_ADAPTIVE_THRESH_MEAN_C)
self._adaptiveMethod.addItem("Gaussian", cv2.cv.CV_ADAPTIVE_THRESH_GAUSSIAN_C)
self._colorDomain = OTParamCombo("Colors space",varname='_param_tb_color_domain')
self._colorDomain.addItem("RGB", -1)
self._colorDomain.addItem("Gray", cv2.COLOR_BGR2GRAY)
self._colorDomain.addItem("XYZ", cv2.COLOR_BGR2XYZ)
self._colorDomain.addItem("YCrCb", cv2.COLOR_BGR2YCR_CB)
self._colorDomain.addItem("HSV", cv2.COLOR_BGR2HSV)
self._colorDomain.addItem("HLS", cv2.COLOR_BGR2HLS)
self._colorDomain.addItem("Lab", cv2.COLOR_BGR2LAB)
self._colorDomain.addItem("Luv", cv2.COLOR_BGR2LUV)
self._colorComponent = OTParamCombo("Component",varname='_param_tb_color_component')
self._colorComponent.addItem("A", 0)
self._colorComponent.addItem("B", 1)
self._colorComponent.addItem("C", 2)
self._formset = [
('_video','_polygons'),"_player",('_colorDomain','_colorComponent','_adaptiveMethod'), ('_boxWidth', '_boxHeight'),('_blockSize',"_C")
]
self._colorDomain.valueUpdated = self.refreshValue
self._colorComponent.valueUpdated = self.refreshValue
self._adaptiveMethod.valueUpdated = self.refreshValue
self._boxHeight.valueUpdated = self.refreshValue
self._boxWidth.valueUpdated = self.refreshValue
self._blockSize.valueUpdated = self.refreshValue
self._C.valueUpdated = self.refreshValue
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
def refreshValue(self, value):
self._player.refresh()
def newVideoInputChoosen(self, value):
OTParamVideoInput.valueUpdated(self._video,value)
if value.videoInput:
self._player.value = value.videoInput
value.videoInput.setFrame(0)
def processFrame(self, frame):
self._video.value.processFrame(frame.copy())
if isinstance(self._video.value, OTModuleColorFilter):
self._original_frame = frame
blobs = OTPThreshBlobs.compute(self, self._video.value._objectsFound)
for blob in blobs:
p1, p2 = blob._tb_cut_bounding
frame[p1[1]:p2[1],p1[0]:p2[0],2] = blob._tb_biggest_img
blob.draw(frame)
else:
frame = OTPThreshImage.compute(self, frame)
return [frame]
def exportCodeTo(self, folder):
files_to_copy = []
classes, imports, constructer_params, parameters = [], [], [], []
classes_tmp, imports_tmp, constructer_params_tmp, parameters_tmp = self._video.value.exportCodeTo(folder)
classes += classes_tmp; imports += imports_tmp; constructer_params += constructer_params_tmp; parameters += parameters_tmp;
#SET OTPRemoveBackground
if isinstance(self._video.value, OTModuleColorFilter):
files_to_copy.append( 'OTPThreshBlobs' )
parameters.append("self._param_tb_color_component = %d " % self._colorComponent.value )
parameters.append("self._param_tb_color_domain = %d " % self._colorDomain.value )
parameters.append("self._param_tb_adaptive_method = %d " % self._adaptiveMethod.value )
parameters.append("self._param_tb_box_height = %d " % self._boxHeight.value )
parameters.append("self._param_tb_box_width = %d " % self._boxWidth.value )
parameters.append("self._param_tb_block_size = %d " % self._blockSize.value )
parameters.append("self._param_tb_c = %d " % self._C.value )
else:
files_to_copy.append( 'OTPThreshImage' )
parameters.append("self._param_tb_color_component = %d " % self._colorComponent.value )
parameters.append("self._param_tb_color_domain = %d " % self._colorDomain.value )
parameters.append("self._param_tb_adaptive_method = %d " % self._adaptiveMethod.value )
parameters.append("self._param_tb_block_size = %d " % self._blockSize.value )
parameters.append("self._param_tb_c = %d " % self._C.value )
#END SET
classes += files_to_copy
for file_to_copy in files_to_copy:
filename = file_to_copy+".py"; originalfilepath = tools.getFileInSameDirectory(__file__, filename); destinyfilepath = os.path.join( folder, filename )
f = open(originalfilepath, 'r'); text = f.read(); f.close(); text = text.replace("from mcvgui.core.controllers.", "from "); f = open(destinyfilepath, 'w'); f.write(text); f.close()
imports.append( "from %s import %s" % (file_to_copy, file_to_copy) )
return classes, imports, constructer_params, parameters
class OTModuleGeometry(OTBaseModuleGeometry):
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'icongeo.png')
OTBaseModuleGeometry.__init__(self,name, iconFile = icon_path)
self._imgWidth = 0.0
self._imgHeight = 0.0
self._startPoint = None
self._endPoint = None
self._selectedPoly = None
self._selectedPoint = None
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video")
self._remove = OTParamButton("Remove")
self._square = OTParamToggle("Square")
self._circle = OTParamToggle("Circle")
self._export = OTParamButton("Export")
self._import = OTParamButton("Import")
self._formset = [ '_video',"_player", ("_square", "_circle", " ","_remove"," ", "_export", "_import"), "=", "_polygons" ]
self._video.valueUpdated = self.videoSelected
self._square.value = self.square_toggle
self._circle.value = self.circle_toggle
self._remove.value = self.remove_clicked
self._export.value = self.export_clicked
self._import.value = self.import_clicked
self._player._videoWidget.onDrag = self.onDragInVideoWindow
self._player._videoWidget.onEndDrag = self.onEndDragInVideoWindow
self._player._videoWidget.onClick = self.onClickInVideoWindow
self._player._videoWidget.onDoubleClick = self.onDoubleClickInVideoWindow
self._player.processFrame = self.processFrame
def export_clicked(self):
filename = str(QFileDialog.getSaveFileName(self._form, 'Choose a file', '') )
if filename!="":
output = open( filename, 'wb')
pickle.dump( self._polygons.value , output)
output.close()
def import_clicked(self):
filename = str(QFileDialog.getOpenFileName(self._form, 'Choose a file', '') )
if filename!="":
pkl_file = open( filename, 'rb'); data = pickle.load(pkl_file); pkl_file.close()
self._polygons.value = data
def processFrame(self, frame):
rows = self._polygons.value
for objIndex, obj in enumerate(rows):
try:
points = eval(obj[1])
cv2.polylines(frame, [numpy.array(points,numpy.int32)], True, (0,255,0), 1, lineType=cv2.CV_AA)
for pointIndex, point in enumerate( points ):
if self._selectedPoint == pointIndex and objIndex==self._selectedPoly:
cv2.circle(frame, point, 2, (255,0,0), 1)
else:
cv2.circle(frame, point, 2, (0,255,0), 1)
except: pass
if self._startPoint and self._endPoint:
if self._square.isChecked():
cv2.rectangle(frame, self._startPoint, self._endPoint, (233,44,44), 1 )
elif self._circle.isChecked() and self._endPoint[0]>self._startPoint[0] and self._endPoint[1]>self._startPoint[1]:
width = self._endPoint[0]-self._startPoint[0]
height = self._endPoint[1]-self._startPoint[1]
center = ( self._startPoint[0] + width/2, self._startPoint[1] + height/2 )
cv2.ellipse( frame, center, (width/2,height/2), 0, 0, 360, (233,44,44), 1 )
return frame
def selectPoint(self,x, y):
rows = self._polygons.value
for objIndex, obj in enumerate(rows):
try:
points = eval(obj[1])
for pointIndex, point in enumerate( points):
mouseCoord = ( x, y )
if tools.pointsDistance( mouseCoord, point ) <= 5:
self._selectedPoint = pointIndex
self._selectedPoly = objIndex
return
self._selectedPoint = None
self._selectedPoly = None
except: pass
def getIntersectionPoint(self, testPoint, point1, point2, tolerance = 5):
vector = ( point2[0]-point1[0], point2[1]-point1[1] )
p0 = point1
if vector[0]!=0:
k = float(testPoint[0] - p0[0]) / float(vector[0])
y = float(p0[1]) + k * float(vector[1])
if point2[0]>point1[0]:
maxValue = point2[0]
minValue = point1[0]
else:
maxValue = point1[0]
minValue = point2[0]
if abs(y-testPoint[1])<=tolerance and testPoint[0]<=maxValue and testPoint[0]>=minValue: return testPoint
else: return None
elif vector[1]!=0:
k = float(testPoint[1] - p0[1]) / float(vector[1])
x = float(p0[0]) + k * float(vector[0])
if point2[1]>point1[1]:
maxValue = point2[1]
minValue = point1[1]
else:
maxValue = point1[1]
minValue = point2[1]
if abs(x-testPoint[0])<=tolerance and testPoint[1]<=maxValue and testPoint[1]>=minValue: return testPoint
else: return None
else: return None
def onDoubleClickInVideoWindow(self, event, x, y):
mouse = ( int(x*self._imgWidth), int(y*self._imgWidth) )
rows = self._polygons.value
for objIndex, obj in enumerate(rows):
try:
points = eval(obj[1])
n_points = len(points)
for pointIndex, point in enumerate( points ):
next_point = points[ (pointIndex+1) % n_points ]
intersection = self.getIntersectionPoint(mouse, point, next_point )
if intersection != None:
self._selectedPoly = objIndex
points.insert( pointIndex + 1, intersection )
self._polygons.setValue( 1, self._selectedPoly, points )
self._selectedPoint = pointIndex + 1
return
except: pass
def onClickInVideoWindow(self, event, x, y):
self.selectPoint( int(x * self._imgWidth), int(y * self._imgWidth) )
def onDragInVideoWindow(self, startPoint, endPoint):
self._startPoint = ( int(startPoint[0] * self._imgWidth), int(startPoint[1] * self._imgWidth) )
self._endPoint = ( int(endPoint[0] * self._imgWidth), int(endPoint[1] * self._imgWidth) )
if self._selectedPoly!=None and self._selectedPoint!=None:
poly = self._polygons.getValue( 1, self._selectedPoly )
try:
points = eval(poly)
points[self._selectedPoint] = self._endPoint
self._polygons.setValue( 1, self._selectedPoly, points )
except: pass
if not self._player.is_playing(): self._player.refresh()
def onEndDragInVideoWindow(self, startPoint, endPoint):
self._startPoint = ( int(startPoint[0] * self._imgWidth), int(startPoint[1] * self._imgWidth) )
self._endPoint = ( int(endPoint[0] * self._imgWidth), int(endPoint[1] * self._imgWidth) )
points = None
if self._square.isChecked():
points = createRectanglePoints(self._startPoint, self._endPoint)
elif self._circle.isChecked() and self._endPoint[0]>self._startPoint[0] and self._endPoint[1]>self._startPoint[1]:
points = createEllipsePoints(self._startPoint, self._endPoint)
if points: self._polygons += ["Poly_%d" % self._polygons.count, points]
self._startPoint = None
self._endPoint = None
self._square.uncheck()
self._circle.uncheck()
def videoSelected(self, value):
if value and value!="" and value.hasVideo():
self._player.value = value
self._imgWidth = float(value.width)
self._imgHeight = float(value.height)
else:
self._player.value = None
def square_toggle(self, checked):
if checked:
self._circle.uncheck()
def circle_toggle(self, checked):
if checked:
self._square.uncheck()
def remove_clicked(self):
self._polygons -= -1 #Remove the selected row
class OTModuleSplitColors(OTModulePlugin, OTModuleInputVideoPipe,
OTPSplitColors):
def __init__(self, name):
icon_path = tools.getFileInSameDirectory(__file__, 'iconsubbg.jpg')
OTPSplitColors.__init__(self)
OTModulePlugin.__init__(self, name, iconFile=icon_path)
self._video = OTParamVideoInput("Video")
self._player = OTParamPlayer("Video player")
self._colorComponent = OTParamCombo("Component",
varname='_split_color_channel')
self._colorComponent.addItem("A", 0)
self._colorComponent.addItem("B", 1)
self._colorComponent.addItem("C", 2)
self._colorComponent.valueUpdated = self.refreshValue
self._formset = [
'_video',
'_colorComponent',
"_player",
]
self._player.processFrame = self.processFrame
self._video.valueUpdated = self.newVideoInputChoosen
def refreshValue(self, value):
self._player.refresh()
def newVideoInputChoosen(self, value):
OTParamVideoInput.valueUpdated(self._video, value)
if value:
self.open(value)
self._player.value = value
def processFrame(self, frame):
filtered = OTPSplitColors.compute(self, frame)
return [frame, filtered]
def exportCodeTo(self, folder):
files_to_copy = []
classes, imports, constructer_params, parameters = [], [], [], []
#classes_tmp, imports_tmp, constructer_params_tmp, parameters_tmp = self._video.value.exportCodeTo(folder)
#classes += classes_tmp; imports += imports_tmp; constructer_params += constructer_params_tmp; parameters += parameters_tmp;
#SET OTPRemoveBackground
if self._removeBg.value:
classes_tmp, imports_tmp, constructer_params_tmp, parameters_tmp = self._background.value.exportCodeTo(
folder)
classes += classes_tmp
imports += imports_tmp
constructer_params += constructer_params_tmp
parameters += parameters_tmp
files_to_copy.append('OTPRemoveBackground')
parameters.append("self._param_background_threshold = %d " %
self._threshold.value)
#END SET
if self._useThreshold.value:
#SET OTPAdaptativeThreshold
files_to_copy.append('OTPAdaptativeThreshold')
parameters.append("self._param_tb_color_component = %d " %
self._colorComponent.value)
parameters.append("self._param_tb_color_domain = %d " %
self._th_colorDomain.value)
parameters.append("self._param_tb_adaptive_method = %d " %
self._adaptiveMethod.value)
parameters.append("self._param_tb_block_size = %d " %
self._blockSize.value)
parameters.append("self._param_tb_threshold_type = %d " %
self._th_thresholdType.value)
parameters.append("self._param_tb_c = %d " % self._C.value)
#END SET
elif self._useCanny.value:
#SET OTPCanny
files_to_copy.append('OTPCanny')
parameters.append("self._param_canny_apertureSize = %d " %
self._canny_apertureSize.value)
parameters.append("self._param_canny_L2gradient = %d " %
self._canny_L2gradient.value)
parameters.append("self._param_canny_threshould1 = %d " %
self._canny_threshould1.value)
parameters.append("self._param_canny_threshould2 = %d " %
self._canny_threshould2.value)
parameters.append("self._param_canny_color_component = %d " %
self._canny_colorComponent.value)
parameters.append("self._param_canny_color_domain = %d " %
self._canny_colorDomain.value)
#END SET
else:
#SET OTPColorFilter
files_to_copy.append('OTPColorFilter')
parameters.append("self._param_color_domain = %d " %
self._colorDomain.value)
parameters.append("self._param_filter_algorithm = '%s' " %
self._textAlgo.value)
parameters.append("self._param_a_min = %d " % self._minR.value)
parameters.append("self._param_a_max = %d " % self._maxR.value)
parameters.append("self._param_b_min = %d " % self._minG.value)
parameters.append("self._param_b_max = %d " % self._maxG.value)
parameters.append("self._param_c_min = %d " % self._minB.value)
parameters.append("self._param_c_max = %d " % self._maxB.value)
#END SET
#SET OTPBlur
if self._useBlur.value:
files_to_copy.append('OTPBlur')
parameters.append("self._param_kernel_size = %d " %
self._kernelSize.value)
parameters.append("self._param_blur_threshould = %d " %
self._blurThreshold.value)
#END SET
#SET OTPMaskImage
if isinstance(self._video.value, OTModuleMaskFromGeometry):
files_to_copy.append('OTPMaskImage')
parameters.append("self._param_mi_polygons = np.array(%s)" %
str(self._video.value._all_polygons))
imports.append("import numpy as np")
#END SET
#SET OTPFindBlobs
if self._exportFindBlobs.value:
files_to_copy.append('OTPFindBlobs')
parameters.append("self._param_min_area = %d " %
self._minArea.value)
parameters.append("self._param_max_area = %d " %
self._maxArea.value)
#END SET
#SET OTPSelectBiggerBlobs
if self._selectBiggests.value:
files_to_copy.append('OTPSelectBiggerBlobs')
parameters.append('self._param_n_blobs = %d' % self._howMany.value)
#END SET
classes += files_to_copy
for file_to_copy in files_to_copy:
filename = file_to_copy + ".py"
originalfilepath = tools.getFileInSameDirectory(
__file__, filename)
destinyfilepath = os.path.join(folder, filename)
f = open(originalfilepath, 'r')
text = f.read()
f.close()
text = text.replace("from mcvgui.core.controllers.", "from ")
f = open(destinyfilepath, 'w')
f.write(text)
f.close()
imports.append("from %s import %s" % (file_to_copy, file_to_copy))
return classes, imports, constructer_params, parameters
