def test_jumpToSeefloorSlice_fractionalFrameWithoutBadBlocks(self): # Setup pixels_in_frame = Frame.FRAME_HEIGHT pixels_in_half_frame = int(pixels_in_frame / 2) drifts_df = pd.DataFrame() drifts_df = self.__append_to_drifts_df(drifts_df, 100, 0, 0) drifts_df = self.__append_to_drifts_df(drifts_df, 200, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 300, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 400, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 500, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 600, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 700, 0, pixels_in_half_frame) driftData = DriftData(drifts_df) badframesData = BadFramesData(None, None) seeFloor = SeeFloor(driftData, badframesData, None, None) # Exercise # Assert self.assertEqual(300, seeFloor.jumpToSeefloorSlice(200, 0.5)) self.assertEqual(267, seeFloor.jumpToSeefloorSlice(200, 0.33333)) self.assertEqual(350, seeFloor.jumpToSeefloorSlice(200, 0.75)) self.assertEqual(450, seeFloor.jumpToSeefloorSlice(200, 1.25)) self.assertEqual(500, seeFloor.jumpToSeefloorSlice(200, 1.5)) self.assertEqual(500, seeFloor.jumpToSeefloorSlice(600, -0.5)) self.assertEqual(290, seeFloor.jumpToSeefloorSlice(600, -1.55))
def regenerateSeefloor(self): driftsStepSize = self.step_size() print "Using driftsStepSize: " + str(driftsStepSize) #TODO: extract logic in few rows into a "regenerate drafts" module/class print("regenerating/interpolating Drafts") manualDrifts = DriftManualData.createFromFile(self.__folderStruct) rawDrifts = DriftRawData(self.__folderStruct) df = rawDrifts.interpolate(manualDrifts, driftsStepSize) drifts = DriftData.createFromFolderStruct(self.__folderStruct) drifts.setDF(df) drifts.saveToFile(self.__folderStruct.getDriftsFilepath()) print("regenerating/interpolating RedDots") rdd = RedDotsData.createFromFolderStruct(self.__folderStruct) rdd.saveInterpolatedDFToFile(drifts.minFrameID(), drifts.maxFrameID() + 1) print("regenerating SeeFloor") sf = SeeFloor.createFromFolderStruct(self.__folderStruct) sf.saveToFile() print("regenerating crabs_on_seefloor") crabs = CrabsData(self.__folderStruct) crabs_on_seefloor_df = crabs.generate_crabs_on_seefloor(sf) crabs_on_seefloor_df.save_file_csv( self.__folderStruct.getCrabsOnSeefloorFilepath())
def test_maxFrameID_noBadFrames(self): # Setup drifts_df = pd.DataFrame() drifts_df = self.__append_to_drifts_df(drifts_df, 95, 0, 16) drifts_df = self.__append_to_drifts_df(drifts_df, 100, 0, 16) drifts_df = self.__append_to_drifts_df(drifts_df, 98, 0, 16) driftData = DriftData(drifts_df) badframesData = BadFramesData(None, None) seeFloor = SeeFloor(driftData, badframesData, None, None) # Exercise maxFrameID = seeFloor.maxFrameID() minFrameID = seeFloor.minFrameID() # Assert self.assertEqual(minFrameID, 95) self.assertEqual(maxFrameID, 100)
def test_maxFrameID_badFramesAtTheEnd(self): # Setup drifts_df = pd.DataFrame() drifts_df = self.__append_to_drifts_df(drifts_df, 95, 0, 16) drifts_df = self.__append_to_drifts_df(drifts_df, 100, 0, 16) drifts_df = self.__append_to_drifts_df(drifts_df, 98, 0, 16) driftData = DriftData(drifts_df) badframes_df = pd.DataFrame() badframes_df = self.__append_to_badframes_df(badframes_df, 99, 101) badframes_df = self.__append_to_badframes_df(badframes_df, 92, 95) badframesData = BadFramesData.createFromDataFrame(None, badframes_df) seeFloor = SeeFloor(driftData, badframesData, None, None) # Exercise minFrameID = seeFloor.minFrameID() maxFrameID = seeFloor.maxFrameID() # Assert self.assertEqual(minFrameID, 96) self.assertEqual(maxFrameID, 98)
def regenerateGraphs(self): print("drawign graphs for RedDots") rdd = RedDotsData.createFromFolderStruct(self.__folderStruct) rdd.saveGraphOfAngle() rdd.saveGraphOfDistance() print("drawing graphs for SeeFloor") sf = SeeFloor.createFromFolderStruct(self.__folderStruct) sf.saveGraphSeefloorY() sf.saveGraphSeefloorX() sf.saveGraphSeefloorXY() sf.saveGraphDriftsMillimeters() sf.saveGraphDriftsPixels()
def test_jumpToSeefloorSlice_badFramesEmpty(self): # Setup pixels_in_frame = Frame.FRAME_HEIGHT pixels_in_half_frame = int(pixels_in_frame / 2) drifts_df = pd.DataFrame() drifts_df = self.__append_to_drifts_df(drifts_df, 100, 0, 0) drifts_df = self.__append_to_drifts_df(drifts_df, 200, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 300, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 400, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 500, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 600, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 700, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 800, 0, pixels_in_half_frame) driftData = DriftData(drifts_df) #badframes_df = pd.DataFrame() badframes_df = BadFramesData.create_empty_df() badframesData = BadFramesData.createFromDataFrame(None, badframes_df) # --- good frames are 150-574 and 625-689. startFrame is 100, endFrame is 700 seeFloor = SeeFloor(driftData, badframesData, None, None) # Exercise # Assert self.assertEqual(100, seeFloor.jumpToSeefloorSlice( 10, 1)) # if parameter is out of bounds show first/last frame self.assertEqual(100, seeFloor.jumpToSeefloorSlice(99, 1)) self.assertEqual(300, seeFloor.jumpToSeefloorSlice(100, 1)) self.assertEqual(600, seeFloor.jumpToSeefloorSlice(200, 2)) self.assertEqual(600, seeFloor.jumpToSeefloorSlice(800, -1)) self.assertEqual(400, seeFloor.jumpToSeefloorSlice(800, -2)) self.assertEqual(500, seeFloor.jumpToSeefloorSlice(700, -1)) self.assertEqual(300, seeFloor.jumpToSeefloorSlice(700, -2))
def __init__(self, imageWin, folderStruct, videoStream, driftData): # type: (ImageWindow, FolderStructure, VideoStream, DriftData) -> ScientistUI self.__zoom = False self.__markingDrift = False self.__contrastLevel = self.CONTRAST_NORMAL self.__imageWin = imageWin self.__folderStruct = folderStruct self.__videoStream = videoStream self.__driftData = driftData self.__badFramesData = BadFramesData.createFromFolderStruct( folderStruct) self.__redDotsData = RedDotsData.createFromFolderStruct(folderStruct) self.__seeFloor = SeeFloor.createFromFolderStruct(folderStruct) self.__seeFloorNoBadBlocks = SeeFloorNoBadBlocks.createFromFolderStruct( folderStruct) self.__crabData = CrabsData(self.__folderStruct) self.__redDotsUI = RedDotsUI(self.__videoStream) self.__markersData = MarkersData(folderStruct) self.__marker_id = "0"
def test_jumpToSeefloorSlice(self): # Setup drifts_df = pd.DataFrame() drifts_df = self.__append_to_drifts_df(drifts_df, 93, 0, 0) drifts_df = self.__append_to_drifts_df(drifts_df, 95, 0, 16) drifts_df = self.__append_to_drifts_df(drifts_df, 100, 0, 16) drifts_df = self.__append_to_drifts_df(drifts_df, 102, 0, 16) drifts_df = self.__append_to_drifts_df(drifts_df, 98, 0, 16) drifts_df = self.__append_to_drifts_df(drifts_df, 104, 0, 16) drifts_df = self.__append_to_drifts_df(drifts_df, 107, 0, 16) driftData = DriftData(drifts_df) badframes_df = pd.DataFrame() badframes_df = self.__append_to_badframes_df(badframes_df, 99, 101) badframes_df = self.__append_to_badframes_df(badframes_df, 104, 108) badframes_df = self.__append_to_badframes_df(badframes_df, 92, 95) badframesData = BadFramesData.createFromDataFrame(None, badframes_df) #--- good frames are 96,97,98 and 102,103. startFrame is 93, endFrame is 107 seeFloor = SeeFloor(driftData, badframesData, None, None) # Exercise # Assert self.assertEqual(93, seeFloor.jumpToSeefloorSlice( -333, 1)) # if parameter is out of bounds show first/last frame self.assertEqual(93, seeFloor.jumpToSeefloorSlice(91, 1)) self.assertEqual(93, seeFloor.jumpToSeefloorSlice(92, 1)) self.assertEqual(96, seeFloor.jumpToSeefloorSlice(93, 1)) self.assertEqual(96, seeFloor.jumpToSeefloorSlice(94, 1)) self.assertEqual(96, seeFloor.jumpToSeefloorSlice(95, 1)) self.assertEqual(98, seeFloor.jumpToSeefloorSlice(96, 1)) self.assertEqual(98, seeFloor.jumpToSeefloorSlice(97, 1)) self.assertEqual(102, seeFloor.jumpToSeefloorSlice(98, 1)) self.assertEqual(102, seeFloor.jumpToSeefloorSlice(99, 1)) self.assertEqual(102, seeFloor.jumpToSeefloorSlice(100, 1)) self.assertEqual(102, seeFloor.jumpToSeefloorSlice(101, 1)) self.assertEqual(103, seeFloor.jumpToSeefloorSlice(102, 1)) self.assertEqual(107, seeFloor.jumpToSeefloorSlice(103, 1)) self.assertEqual(107, seeFloor.jumpToSeefloorSlice(104, 1)) self.assertEqual(107, seeFloor.jumpToSeefloorSlice(105, 1)) self.assertEqual(107, seeFloor.jumpToSeefloorSlice(106, 1)) self.assertEqual(107, seeFloor.jumpToSeefloorSlice(107, 1)) self.assertEqual(107, seeFloor.jumpToSeefloorSlice(108, 1)) self.assertEqual(107, seeFloor.jumpToSeefloorSlice( 2222, 1)) # if parameter is out of bounds show first/last frame self.assertEqual(107, seeFloor.jumpToSeefloorSlice(109, 1)) self.assertEqual(93, seeFloor.jumpToSeefloorSlice( -333, -1)) # if parameter is out of bounds show first/last frame self.assertEqual(93, seeFloor.jumpToSeefloorSlice( 91, -1)) #<-- out-of-bound frame self.assertEqual(93, seeFloor.jumpToSeefloorSlice( 92, -1)) #<-- out-of-bound frame self.assertEqual(93, seeFloor.jumpToSeefloorSlice( 93, -1)) #<-- 93 is bad frame - its FIRST frame self.assertEqual(93, seeFloor.jumpToSeefloorSlice( 94, -1)) #<-- 94 is bad frame self.assertEqual(93, seeFloor.jumpToSeefloorSlice( 95, -1)) #<-- 95 is bad frame self.assertEqual(93, seeFloor.jumpToSeefloorSlice(96, -1)) self.assertEqual(96, seeFloor.jumpToSeefloorSlice(97, -1)) self.assertEqual(96, seeFloor.jumpToSeefloorSlice(98, -1)) self.assertEqual(98, seeFloor.jumpToSeefloorSlice( 99, -1)) #<-- 99 is bad frame self.assertEqual(98, seeFloor.jumpToSeefloorSlice( 100, -1)) #<-- 100 is bad frame self.assertEqual(98, seeFloor.jumpToSeefloorSlice( 101, -1)) #<-- 101 is bad frame self.assertEqual(98, seeFloor.jumpToSeefloorSlice(102, -1)) self.assertEqual(102, seeFloor.jumpToSeefloorSlice(103, -1)) self.assertEqual(103, seeFloor.jumpToSeefloorSlice( 104, -1)) #<-- 104 is bad frame self.assertEqual(103, seeFloor.jumpToSeefloorSlice( 105, -1)) #<-- 105 is bad frame self.assertEqual(103, seeFloor.jumpToSeefloorSlice( 106, -1)) #<-- 106 is bad frame self.assertEqual(103, seeFloor.jumpToSeefloorSlice( 107, -1)) #<-- 107 is bad frame - its LAST frame self.assertEqual(107, seeFloor.jumpToSeefloorSlice( 108, -1)) #<-- out-of-bound frame self.assertEqual(107, seeFloor.jumpToSeefloorSlice( 2222, -1)) #<-- out-of-bound frame self.assertEqual(107, seeFloor.jumpToSeefloorSlice( 109, -1)) #<-- out-of-bound frame
def test_jumpToSeefloorSlice_multiSlice_goingDownward(self): # Setup pixels_in_frame = Frame.FRAME_HEIGHT pixels_in_half_frame = int(pixels_in_frame / 2) drifts_df = pd.DataFrame() drifts_df = self.__append_to_drifts_df(drifts_df, 100, 0, 0) drifts_df = self.__append_to_drifts_df(drifts_df, 200, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 300, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 400, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 500, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 600, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 700, 0, pixels_in_half_frame) driftData = DriftData(drifts_df) badframes_df = pd.DataFrame() badframes_df = self.__append_to_badframes_df(badframes_df, 90, 149) badframes_df = self.__append_to_badframes_df(badframes_df, 575, 624) badframes_df = self.__append_to_badframes_df(badframes_df, 690, 790) badframesData = BadFramesData.createFromDataFrame(None, badframes_df) #--- good frames are 150-574 and 625-689. startFrame is 100, endFrame is 700 seeFloor = SeeFloor(driftData, badframesData, None, None) # Exercise # Assert self.assertEqual(100, seeFloor.jumpToSeefloorSlice( 10, -1)) # if parameter is out of bounds show first/last frame self.assertEqual(100, seeFloor.jumpToSeefloorSlice(99, -1)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(100, -1)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(101, -1)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(149, -1)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(150, -1)) self.assertEqual(150, seeFloor.jumpToSeefloorSlice(151, -1)) self.assertEqual(150, seeFloor.jumpToSeefloorSlice(175, -1)) self.assertEqual(150, seeFloor.jumpToSeefloorSlice(348, -1)) self.assertEqual(150, seeFloor.jumpToSeefloorSlice(349, -1)) self.assertEqual(151, seeFloor.jumpToSeefloorSlice(350, -1)) self.assertEqual(152, seeFloor.jumpToSeefloorSlice(351, -1)) self.assertEqual(374, seeFloor.jumpToSeefloorSlice(573, -1)) self.assertEqual(375, seeFloor.jumpToSeefloorSlice(574, -1)) #<--- ?? self.assertEqual(574, seeFloor.jumpToSeefloorSlice(575, -1)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(576, -1)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(623, -1)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(624, -1)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(625, -1)) self.assertEqual(625, seeFloor.jumpToSeefloorSlice(626, -1)) self.assertEqual(625, seeFloor.jumpToSeefloorSlice(627, -1)) self.assertEqual(625, seeFloor.jumpToSeefloorSlice(687, -1)) self.assertEqual(625, seeFloor.jumpToSeefloorSlice(688, -1)) self.assertEqual(625, seeFloor.jumpToSeefloorSlice(689, -1)) self.assertEqual(689, seeFloor.jumpToSeefloorSlice(690, -1)) self.assertEqual(689, seeFloor.jumpToSeefloorSlice(691, -1)) self.assertEqual(689, seeFloor.jumpToSeefloorSlice(699, -1)) self.assertEqual(689, seeFloor.jumpToSeefloorSlice(700, -1)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(701, -1)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(702, -1)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice( 10, -2)) # if parameter is out of bounds show first/last frame self.assertEqual(100, seeFloor.jumpToSeefloorSlice(99, -2)) # step 1 is to jump over bad block, step 2 is to jump 200 frames self.assertEqual(375, seeFloor.jumpToSeefloorSlice(600, -2)) self.assertEqual(375, seeFloor.jumpToSeefloorSlice(575, -2)) #TODO: why 176 and not 175? where did extra 1 come from self.assertEqual(176, seeFloor.jumpToSeefloorSlice( 574, -2)) #<--- why 176 and not 175? where did extra 1 come from self.assertEqual(175, seeFloor.jumpToSeefloorSlice(573, -2)) #TODO:fix test cases below # normal 2 jumps without any bad blocks in the middle self.assertEqual(152, seeFloor.jumpToSeefloorSlice(550, -2)) self.assertEqual(151, seeFloor.jumpToSeefloorSlice(549, -2)) self.assertEqual(150, seeFloor.jumpToSeefloorSlice(548, -2)) self.assertEqual(150, seeFloor.jumpToSeefloorSlice(547, -2)) self.assertEqual( 150, seeFloor.jumpToSeefloorSlice(546, -2) ) #<-- ?? why diff input but same output. Who is rounding where? self.assertEqual( 150, seeFloor.jumpToSeefloorSlice(545, -2) ) #<-- ?? why diff input but same output. Who is rounding where? self.assertEqual( 150, seeFloor.jumpToSeefloorSlice(351, -2) ) #<-- ?? why diff input but same output. Who is rounding where? self.assertEqual(150, seeFloor.jumpToSeefloorSlice(350, -2)) self.assertEqual( 100, seeFloor.jumpToSeefloorSlice(349, -2) ) #<-- ?? why diff input but same output. Who is rounding where? self.assertEqual(100, seeFloor.jumpToSeefloorSlice(348, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(348, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(152, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(151, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(150, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(149, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(148, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(147, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(103, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(102, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(101, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(100, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(99, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(98, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(92, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(91, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(90, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(89, -2)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(88, -2)) # jump #1 is 200 frames, then second jump is shorter to the last good frame before bad block self.assertEqual(689, seeFloor.jumpToSeefloorSlice(700, -1)) self.assertEqual(625, seeFloor.jumpToSeefloorSlice(700, -2)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(700, -3)) self.assertEqual(375, seeFloor.jumpToSeefloorSlice(700, -4)) self.assertEqual(176, seeFloor.jumpToSeefloorSlice( 700, -5)) #<-- ?? why not 175? self.assertEqual(150, seeFloor.jumpToSeefloorSlice(700, -6)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(700, -7)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice(700, -8)) self.assertEqual(176, seeFloor.jumpToSeefloorSlice(699, -5)) self.assertEqual(176, seeFloor.jumpToSeefloorSlice(698, -5)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(701, -1)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(701, -2)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(701, -3)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(702, -3))
def test_jumpToSeefloorSlice_multiSlice_goingUpward(self): # Setup pixels_in_frame = Frame.FRAME_HEIGHT pixels_in_half_frame = int(pixels_in_frame / 2) drifts_df = pd.DataFrame() drifts_df = self.__append_to_drifts_df(drifts_df, 100, 0, 0) drifts_df = self.__append_to_drifts_df(drifts_df, 200, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 300, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 400, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 500, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 600, 0, pixels_in_half_frame) drifts_df = self.__append_to_drifts_df(drifts_df, 700, 0, pixels_in_half_frame) driftData = DriftData(drifts_df) badframes_df = pd.DataFrame() badframes_df = self.__append_to_badframes_df(badframes_df, 90, 149) badframes_df = self.__append_to_badframes_df(badframes_df, 575, 624) badframes_df = self.__append_to_badframes_df(badframes_df, 690, 790) badframesData = BadFramesData.createFromDataFrame(None, badframes_df) #--- good frames are 150-574 and 625-689. startFrame is 100, endFrame is 700 seeFloor = SeeFloor(driftData, badframesData, None, None) # Exercise # Assert self.assertEqual(510, seeFloor.jumpToSeefloorSlice(500, 0.05)) self.assertEqual(560, seeFloor.jumpToSeefloorSlice(500, 0.30)) self.assertEqual(561, seeFloor.jumpToSeefloorSlice(500, 0.305)) self.assertEqual(563, seeFloor.jumpToSeefloorSlice(500, 0.31)) self.assertEqual(565, seeFloor.jumpToSeefloorSlice(500, 0.32)) self.assertEqual(567, seeFloor.jumpToSeefloorSlice(500, 0.33)) self.assertEqual(569, seeFloor.jumpToSeefloorSlice(500, 0.34)) self.assertEqual(571, seeFloor.jumpToSeefloorSlice(500, 0.35)) self.assertEqual(573, seeFloor.jumpToSeefloorSlice(500, 0.36)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(500, 0.37)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(500, 0.38)) #?? self.assertEqual(574, seeFloor.jumpToSeefloorSlice(500, 0.39)) #?? self.assertEqual(574, seeFloor.jumpToSeefloorSlice(500, 1)) self.assertEqual(625, seeFloor.jumpToSeefloorSlice(500, 1.1)) self.assertEqual(625, seeFloor.jumpToSeefloorSlice(500, 1.36)) #?? self.assertEqual(625, seeFloor.jumpToSeefloorSlice(500, 1.39)) #?? self.assertEqual(625, seeFloor.jumpToSeefloorSlice(500, 1.34)) #?? self.assertEqual(625, seeFloor.jumpToSeefloorSlice(500, 2)) #?? self.assertEqual(646, seeFloor.jumpToSeefloorSlice(500, 2.1)) #?? self.assertEqual(100, seeFloor.jumpToSeefloorSlice( 10, 1)) # if parameter is out of bounds show first/last frame self.assertEqual(100, seeFloor.jumpToSeefloorSlice(99, 1)) self.assertEqual(150, seeFloor.jumpToSeefloorSlice(100, 1)) self.assertEqual(150, seeFloor.jumpToSeefloorSlice(101, 1)) self.assertEqual(150, seeFloor.jumpToSeefloorSlice(149, 1)) self.assertEqual(350, seeFloor.jumpToSeefloorSlice(150, 1)) self.assertEqual(352, seeFloor.jumpToSeefloorSlice(151, 1)) #<>>> self.assertEqual(353, seeFloor.jumpToSeefloorSlice(152, 1)) #<>>> self.assertEqual(375, seeFloor.jumpToSeefloorSlice(175, 1)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(572, 1)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(573, 1)) self.assertEqual(625, seeFloor.jumpToSeefloorSlice(574, 1)) self.assertEqual(625, seeFloor.jumpToSeefloorSlice(575, 1)) self.assertEqual(625, seeFloor.jumpToSeefloorSlice(623, 1)) self.assertEqual(625, seeFloor.jumpToSeefloorSlice(624, 1)) self.assertEqual(689, seeFloor.jumpToSeefloorSlice(625, 1)) self.assertEqual(689, seeFloor.jumpToSeefloorSlice(626, 1)) self.assertEqual(689, seeFloor.jumpToSeefloorSlice(627, 1)) self.assertEqual(689, seeFloor.jumpToSeefloorSlice(687, 1)) self.assertEqual(689, seeFloor.jumpToSeefloorSlice(688, 1)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(689, 1)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(690, 1)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(691, 1)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(699, 1)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(700, 1)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(701, 1)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(702, 1)) self.assertEqual(100, seeFloor.jumpToSeefloorSlice( 10, 2)) # if parameter is out of bounds show first/last frame self.assertEqual(100, seeFloor.jumpToSeefloorSlice(99, 2)) # step 1 is to jump over bad block, step 2 is to jump 200 frames self.assertEqual(350, seeFloor.jumpToSeefloorSlice(100, 2)) self.assertEqual(350, seeFloor.jumpToSeefloorSlice(101, 2)) self.assertEqual(350, seeFloor.jumpToSeefloorSlice(149, 2)) # normal 2 jumps without any bad blocks in the middle self.assertEqual(550, seeFloor.jumpToSeefloorSlice(150, 2)) self.assertEqual(553, seeFloor.jumpToSeefloorSlice(151, 2)) self.assertEqual(554, seeFloor.jumpToSeefloorSlice(152, 2)) self.assertEqual(555, seeFloor.jumpToSeefloorSlice(153, 2)) self.assertEqual(555, seeFloor.jumpToSeefloorSlice( 154, 2)) #<-- ?? why diff input but same output. Who is rounding where? self.assertEqual(555, seeFloor.jumpToSeefloorSlice( 155, 2)) #<-- ?? why diff input but same output. Who is rounding where? self.assertEqual(558, seeFloor.jumpToSeefloorSlice(156, 2)) self.assertEqual(559, seeFloor.jumpToSeefloorSlice(157, 2)) self.assertEqual(560, seeFloor.jumpToSeefloorSlice(158, 2)) self.assertEqual(560, seeFloor.jumpToSeefloorSlice( 159, 2)) #<-- ?? why diff input but same output. Who is rounding where? self.assertEqual(560, seeFloor.jumpToSeefloorSlice( 160, 2)) #<-- ?? why diff input but same output. Who is rounding where? # jump #1 is 200 frames, then second jump is shorter to the last good frame before bad block self.assertEqual(574, seeFloor.jumpToSeefloorSlice(172, 2)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(173, 2)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(174, 2)) #<-- ?? self.assertEqual(574, seeFloor.jumpToSeefloorSlice(175, 2)) #<-- ?? self.assertEqual(574, seeFloor.jumpToSeefloorSlice(176, 2)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(177, 2)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(178, 2)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(179, 2)) self.assertEqual(574, seeFloor.jumpToSeefloorSlice(180, 2)) self.assertEqual(625, seeFloor.jumpToSeefloorSlice(180, 3)) self.assertEqual(689, seeFloor.jumpToSeefloorSlice(180, 4)) self.assertEqual(700, seeFloor.jumpToSeefloorSlice(180, 5))
rootDir = "C:/workspaces/AnjutkaVideo/2020-Kara/2020.09.16_6922" videoFileName = "R_20200916_194953_20200916_195355" # rootDir = "C:/workspaces/AnjutkaVideo/2020-Kara/2020.09.18_6923" # videoFileName = "R_20200918_111643_20200918_112107" folderStruct = FolderStructure(rootDir, videoFileName) StreamToLogger(folderStruct.getLogFilepath()) print("Starting to cut video into frames") interpolator = InterpolateController(folderStruct) interpolator.regenerateSeefloor() seefloorGeometry = SeeFloor.createFromFolderStruct(folderStruct) videoStream = VideoStream(folderStruct.getVideoFilepath()) framesStitcher = VideoToImages(seefloorGeometry, videoStream) #framesToSaveToFile = framesStitcher.determineFrames() #print("Dataframe Contains:", framesToSaveToFile) frameIDs = framesStitcher.getListOfFrameIDs() framesStitcher.saveFramesToFile(frameIDs, folderStruct.getFramesDirpath()) loggerFramesCSV = Logger.openInOverwriteMode(folderStruct.getFramesFilepath()) framesStitcher.saveFramesToCSVFile(frameIDs, loggerFramesCSV) crabsData = CrabsData(folderStruct) lst = crabsData.allFramesWithCrabs()