def test_debug_no_coordinates(self):
"""Test debug mode without coordinate conversion"""
pd = PlantDetection(image="plant_detection/soil_image.jpg",
text_output=False, save=False,
debug=True)
pd.detect_plants()
self.assertTrue(os.path.exists('soil_image_masked_original.jpg'))
def setUp(self):
os.environ.clear()
self.data = {
'WEED_DETECTOR_blur': 15,
'WEED_DETECTOR_morph': 6,
'WEED_DETECTOR_iteration': 4,
'WEED_DETECTOR_H_HI': 90,
'WEED_DETECTOR_H_LO': 30,
'WEED_DETECTOR_S_HI': 255,
'WEED_DETECTOR_S_LO': 20,
'WEED_DETECTOR_V_HI': 255,
'WEED_DETECTOR_V_LO': 20
}
for key, value in self.data.items():
os.environ[key] = str(value)
self.input_params = {
'blur': self.data['WEED_DETECTOR_blur'],
'morph': self.data['WEED_DETECTOR_morph'],
'iterations': self.data['WEED_DETECTOR_iteration'],
'H':
[self.data['WEED_DETECTOR_H_LO'], self.data['WEED_DETECTOR_H_HI']],
'S':
[self.data['WEED_DETECTOR_S_LO'], self.data['WEED_DETECTOR_S_HI']],
'V':
[self.data['WEED_DETECTOR_V_LO'], self.data['WEED_DETECTOR_V_HI']]
}
self.pd = PlantDetection(image='plant_detection/soil_image.jpg',
from_env_var=True,
text_output=False,
save=False)
# os.environ["PLANT_DETECTION_options"] = json.dumps(self.input_params)
self.pd.detect_plants()
def setUp(self):
self.calibration = {
'blur': 5,
'morph': 15,
'calibration_iters': 3,
'H': [160, 20],
'S': [100, 255],
'V': [100, 255],
'easy_calibration': False,
'calibration_circles_xaxis': True,
'camera_offset_coordinates': [200, 100],
'image_bot_origin_location': [0, 1],
'calibration_circle_separation': 1000
}
self.pd = PlantDetection(
image='plant_detection/soil_image.jpg',
calibration_img='plant_detection/p2c_test_calibration.jpg',
calibration_data=self.calibration,
text_output=False,
save=False)
self.pd.calibrate()
self.input_params = {
'blur': 15,
'morph': 6,
'iterations': 4,
'H': [30, 90],
'S': [20, 255],
'V': [20, 255],
'save_detected_plants': False,
'use_bounds': False,
'min_radius': 0,
'max_radius': 0,
}
def test_verbose_text_output_no_coordinates(self):
"""Test verbose text output without coordinate conversion"""
pd = PlantDetection(image="plant_detection/soil_image.jpg",
save=False,
print_all_json=True)
pd.detect_plants()
check_file_length(self, 71 if USING_FT else 69)
def setUp(self):
self.calibration = {
'blur': 5,
'morph': 15,
'calibration_iters': 3,
'H': [160, 20],
'S': [100, 255],
'V': [100, 255],
'calibration_circles_xaxis': True,
'camera_offset_coordinates': [200, 100],
'image_bot_origin_location': [0, 1],
'calibration_circle_separation': 1000
}
self.pd = PlantDetection(
image="plant_detection/soil_image.jpg",
calibration_img="plant_detection/p2c_test_calibration.jpg",
calibration_data=self.calibration,
text_output=False,
save=False)
self.pd.calibrate()
self.input_params = {
"blur": 15,
"morph": 6,
"iterations": 4,
"H": [30, 90],
"S": [20, 255],
"V": [20, 255]
}
def setUp(self):
pd = PlantDetection(image="plant_detection/soil_image.jpg",
text_output=False, save=False,
grey_out=True)
pd.detect_plants()
self.pixel_mean = get_average_pixel_value(pd.image.images['current'])
self.expected_pixel_mean = 138.7
def execute_sequence_init(self):
log('Execute move: ',
message_type='debug',
title=str(self.farmwarename))
move_absolute(location=[400, 100, 0], offset=[0, 0, 0], speed=800)
PD = PlantDetection(coordinates=True, app=True)
PD.detect_plants()
def plantDetect(imagePath):
PD = PlantDetection(image=imagePath, verbose=False, text_output=False)
try:
PD.detect_plants()
print("python test.py -i " + picPath + ".jpg")
except:
GPIO.cleanup()
pass
def setUp(self):
pd = PlantDetection(image="plant_detection/soil_image.jpg",
text_output=False, save=False,
draw_contours=True,
circle_plants=False)
pd.detect_plants()
self.pixel_mean = get_average_pixel_value(pd.image.images['current'])
self.expected_pixel_mean = 72.9
def test_condensed_text_output_no_coordinates(self):
"""Test condensed text output without coordinate conversion"""
pd = PlantDetection(
image="plant_detection/soil_image.jpg",
verbose=False,
save=False, print_all_json=True)
pd.detect_plants()
check_file_length(self, 8)
def test_set_inputs(self):
"""Set input environment variable"""
pd = PlantDetection(image="plant_detection/soil_image.jpg",
from_env_var=True,
text_output=False,
save=False)
pd.detect_plants()
self.assertEqual(pd.params.parameters, self.input_params)
def setUp(self):
"""Test clump buster"""
self.pd = PlantDetection(
image="plant_detection/soil_image.jpg",
morph=10,
text_output=False, save=False, clump_buster=True)
self.pd.detect_plants()
self.object_count = 39
class TestFromFile(unittest.TestCase):
"""Test file use"""
def setUp(self):
self.outfile = open('text_output_test.txt', 'w')
sys.stdout = self.outfile
# Generate and save calibration data
self.pd = PlantDetection(
calibration_img="plant_detection/p2c_test_calibration.jpg",
text_output=False,
save=False)
self.pd.calibrate()
self.pd.p2c.save_calibration_parameters()
# Expected number of objects detected
self.object_count = 16
def test_detect_coordinates(self):
"""Detect coordinates, getting calibration parameters from file"""
# Set input parameters for detection
pdx = PlantDetection()
pdx.params.parameters = {
'blur': 15,
'morph': 6,
'iterations': 4,
'H': [30, 90],
'S': [20, 255],
'V': [20, 255]
}
pdx.params.save()
# Load the set parameters
pd = PlantDetection(image="plant_detection/soil_image.jpg",
from_file=True,
coordinates=True,
text_output=False,
save=False)
pd.detect_plants()
self.assertEqual(pd.plant_db.object_count, self.object_count)
def test_calibration(self):
"""Load calibration input from file"""
# Set input parameters for calibration
pdx = PlantDetection()
pdx.params.parameters['H'] = [160, 20]
pdx.params.save()
# Load the set parameters
pd = PlantDetection(
calibration_img="plant_detection/p2c_test_calibration.jpg",
from_file=True,
text_output=False,
save=False,
debug=True)
pd.calibrate()
self.assertEqual(pd.plant_db.object_count, 2)
def tearDown(self):
self.outfile.close()
sys.stdout = sys.__stdout__
os.remove('text_output_test.txt')
def test_array_detect_debug(self):
"""Detect plants using array input and debug"""
pd = PlantDetection(
image="plant_detection/soil_image.jpg",
array=[{"size": 5, "kernel": 'ellipse', "type": 'close', "iters": 2},
{"size": 3, "kernel": 'ellipse', "type": 'open', "iters": 8}],
text_output=False, save=False, debug=True)
pd.detect_plants()
object_count = 25
self.assertEqual(pd.plant_db.object_count, object_count)
def test_array_detect_simple(self):
"""Detect plants using simple array input"""
pd = PlantDetection(
image="plant_detection/soil_image.jpg",
array=[{"size": 5, "kernel": 'ellipse', "type": 'erode', "iters": 2},
{"size": 3, "kernel": 'ellipse', "type": 'dilate', "iters": 8}],
text_output=False, save=False)
pd.detect_plants()
object_count = 29
self.assertEqual(pd.plant_db.object_count, object_count)
def setUp(self):
self.outfile = open('text_output_test.txt', 'w')
sys.stdout = self.outfile
# Generate and save calibration data
self.pd = PlantDetection(
calibration_img="plant_detection/p2c_test_calibration.jpg",
text_output=False, save=False)
self.pd.calibrate()
self.pd.p2c.save_calibration_parameters()
# Expected number of objects detected
self.object_count = 16
def test_calibration(self):
"""Load calibration input from file"""
# Set input parameters for calibration
pdx = PlantDetection()
pdx.params.parameters['H'] = [160, 20]
pdx.params.save()
# Load the set parameters
pd = PlantDetection(calibration_img="plant_detection/p2c_test_calibration.jpg",
from_file=True,
text_output=False, save=False, debug=True)
pd.calibrate()
self.assertEqual(pd.plant_db.object_count, 2)
def setUp(self):
self.parameters = {
'blur': 5,
'morph': 5,
'iterations': 1,
'H': [30, 90],
'S': [20, 255],
'V': [20, 255]
}
self.pd = PlantDetection(image='plant_detection/soil_image.jpg',
text_output=False,
save=False)
self.pd.detect_plants()
def test_detect_coordinates(self):
"""Detect coordinates, getting calibration parameters from file"""
# Set input parameters for detection
pdx = PlantDetection()
pdx.params.parameters = {'blur': 15, 'morph': 6, 'iterations': 4,
'H': [30, 90], 'S': [20, 255], 'V': [20, 255]}
pdx.params.save()
# Load the set parameters
pd = PlantDetection(image="plant_detection/soil_image.jpg",
from_file=True, coordinates=True,
text_output=False, save=False)
pd.detect_plants()
self.assertEqual(pd.plant_db.object_count, self.object_count)
def process_images_from_path(input_path):
"""
Resize all images given a path.
"""
print("----------------PROCESS IMAGES FROM PATH----------------")
# Resize all images
for f in os.listdir(input_path):
if ('jpg' or 'png' or 'jpeg' or 'bmp') in f:
print(str(input_path + f))
PD = PlantDetection(image=input_path + f,
morph=15,
iterations=2,
debug=True,
HSV_min=[0, 59, 151],
HSV_max=[20, 138, 212],
array=[
{
"size": 3,
"kernel": 'ellipse',
"type": 'erode',
"iters": 5
},
{
"size": 5,
"kernel": 'ellipse',
"type": 'dilate',
"iters": 10
},
])
PD.detect_plants()
# print(f[:-4]+'_contours.jpg')
# print(f[:-4]+'_morphed_original.jpg')
# print(f[:-4]+'_marked.jpg')
c = cv.imread(f[:-4] + '_contours.jpg')
mo = cv.imread(f[:-4] + '_morphed_original.jpg')
ma = cv.imread(f[:-4] + '_marked.jpg')
# print(output_path+'contours/'+f+'_contours.jpg')
# print(output_path+'marked/'+f+'_morphed_original.jpg')
# print(output_path+'morphed_original/'+f+'_marked.jpg')
cv.imwrite('output/contours/' + f[:-4] + '_contours.jpg', c)
cv.imwrite('output/marked/' + f[:-4] + '_marked.jpg', mo)
cv.imwrite(
'output/morphed_original/' + f[:-4] + '_morphed_original.jpg',
ma)
class PDTestNoJSONinput(unittest.TestCase):
"""Test defaults"""
def setUp(self):
self.parameters = {'blur': 5, 'morph': 5, 'iterations': 1,
'H': [30, 90], 'S': [20, 255], 'V': [20, 255]}
self.pd = PlantDetection(
image='plant_detection/soil_image.jpg', text_output=False, save=False)
self.pd.detect_plants()
def test_json_parameters_input(self):
"""Do not load JSON input parameters from ENV VAR"""
self.assertEqual(self.pd.plant_db.plants['known'], [])
self.assertEqual(self.pd.params.parameters, self.parameters)
class PDTestJSONinput(unittest.TestCase):
"""Test ENV VAR inputs"""
def setUp(self):
os.environ.clear()
self.data = {
'WEED_DETECTOR_blur': 15,
'WEED_DETECTOR_morph': 6,
'WEED_DETECTOR_iteration': 4,
'WEED_DETECTOR_H_HI': 90,
'WEED_DETECTOR_H_LO': 30,
'WEED_DETECTOR_S_HI': 255,
'WEED_DETECTOR_S_LO': 20,
'WEED_DETECTOR_V_HI': 255,
'WEED_DETECTOR_V_LO': 20,
'WEED_DETECTOR_save_detected_plants': '"TRUE"',
'WEED_DETECTOR_use_bounds': '"TRUE"',
'WEED_DETECTOR_min_radius': 1,
'WEED_DETECTOR_max_radius': 100,
}
for key, value in self.data.items():
os.environ[key] = str(value)
self.input_params = {
'blur': self.data['WEED_DETECTOR_blur'],
'morph': self.data['WEED_DETECTOR_morph'],
'iterations': self.data['WEED_DETECTOR_iteration'],
'H':
[self.data['WEED_DETECTOR_H_LO'], self.data['WEED_DETECTOR_H_HI']],
'S':
[self.data['WEED_DETECTOR_S_LO'], self.data['WEED_DETECTOR_S_HI']],
'V':
[self.data['WEED_DETECTOR_V_LO'], self.data['WEED_DETECTOR_V_HI']],
'save_detected_plants': True,
'use_bounds': True,
'min_radius': 1,
'max_radius': 100,
}
self.pd = PlantDetection(image='plant_detection/soil_image.jpg',
from_env_var=True,
text_output=False,
save=False)
# os.environ["PLANT_DETECTION_options"] = json.dumps(self.input_params)
self.pd.detect_plants()
def test_json_parameters_input(self):
"""Load JSON input parameters from ENV VAR"""
self.assertEqual(self.pd.params.parameters, self.input_params)
def tearDown(self):
os.environ.clear()
class PDTestClumpBuster(unittest.TestCase):
"""Test other options"""
def setUp(self):
"""Test clump buster"""
self.pd = PlantDetection(image="plant_detection/soil_image.jpg",
morph=10,
text_output=False,
save=False,
clump_buster=True)
self.pd.detect_plants()
self.object_count = 39
def test_clump_buster(self):
"""Test clump buster"""
self.assertEqual(self.pd.plant_db.object_count, self.object_count)
def test_input_defaults(self):
"""Use defaults"""
pd = PlantDetection()
self.assertEqual(pd.args, self.default_func_args)
self.assertEqual(pd.plant_db.plants['known'], [])
self.assertEqual(pd.params.parameters, self.default_input_params)
self.assertEqual(pd.params.array, None)
def setUp(self):
self.parameters = {
'blur': 5,
'morph': 5,
'iterations': 1,
'H': [30, 90],
'S': [20, 255],
'V': [20, 255],
'save_detected_plants': False,
'use_bounds': False,
'min_radius': 0,
'max_radius': 0,
}
self.pd = PlantDetection(image='plant_detection/soil_image.jpg',
text_output=False,
save=False)
self.pd.detect_plants()
def setUp(self):
# self.maxDiff = None
self.calibration = {'blur': 5, 'morph': 15, 'calibration_iters': 3,
'H': [160, 20], 'S': [100, 255], 'V': [100, 255],
'easy_calibration': False,
'calibration_circles_xaxis': True,
'camera_offset_coordinates': [200, 100],
'image_bot_origin_location': [0, 1],
'calibration_circle_separation': 1000}
self.pd = PlantDetection(image="plant_detection/soil_image.jpg",
calibration_img="plant_detection/p2c_test_calibration.jpg",
calibration_data=self.calibration,
known_plants=[{'x': 200, 'y': 600, 'radius': 100},
{'x': 900, 'y': 200, 'radius': 120}],
blur=15, morph=6, iterations=4,
text_output=False, save=False)
self.pd.calibrate()
self.pd.detect_plants()
self.input_params = {'blur': 15, 'morph': 6, 'iterations': 4,
'H': [30, 90], 'S': [20, 255], 'V': [20, 255]}
self.calibration.update({'total_rotation_angle': 0.0,
'coord_scale': 1.7182,
'center_pixel_location': [465, 290]})
self.object_count = 16
self.plants = {
'known': [{'y': 600, 'x': 200, 'radius': 100},
{'y': 200, 'x': 900, 'radius': 120}],
'save': [{'y': 189.01, 'x': 901.37, 'radius': 65.32},
{'y': 579.04, 'x': 236.43, 'radius': 91.23}],
'safe_remove': [{'y': 85.91, 'x': 837.8, 'radius': 80.52}],
'remove': [{'y': 41.24, 'x': 1428.86, 'radius': 73.59},
{'y': 42.96, 'x': 607.56, 'radius': 82.26},
{'y': 103.1, 'x': 1260.48, 'radius': 3.44},
{'y': 152.92, 'x': 1214.09, 'radius': 62.0},
{'y': 216.5, 'x': 1373.88, 'radius': 13.82},
{'y': 231.96, 'x': 1286.25, 'radius': 61.8},
{'y': 285.23, 'x': 1368.72, 'radius': 14.4},
{'y': 412.37, 'x': 1038.83, 'radius': 73.97},
{'y': 479.38, 'x': 1531.95, 'radius': 80.96},
{'y': 500.0, 'x': 765.64, 'radius': 80.02},
{'y': 608.25, 'x': 1308.59, 'radius': 148.73},
{'y': 676.97, 'x': 59.46, 'radius': 60.95},
{'y': 914.09, 'x': 62.89, 'radius': 82.37},
{'y': 84.2, 'x': 772.51, 'radius': 20.06}]
}
def test_input_args(self):
"""Set all arguments"""
self.maxDiff = None
pd = PlantDetection(**self.func_args)
self.assertEqual(pd.args, self.func_args)
self.assertEqual(pd.plant_db.plants['known'],
self.func_args['known_plants'])
self.assertEqual(pd.params.parameters, self.set_input_params)
self.assertEqual(pd.params.array, self.func_args['array'])
def setUp(self):
self.calibration_json = {
'blur': 5,
'morph': 15,
'calibration_iters': 3,
'H': [160, 20],
'S': [100, 255],
'V': [100, 255],
'easy_calibration': False,
'calibration_circles_xaxis': True,
'camera_offset_coordinates': [200, 100],
'image_bot_origin_location': [0, 1],
'calibration_circle_separation': 1000,
'invert_hue_selection': True
}
self.pd = PlantDetection(
image='plant_detection/p2c_test_objects.jpg',
calibration_img='plant_detection/p2c_test_calibration.jpg',
calibration_data=self.calibration_json,
HSV_min=[160, 100, 100],
HSV_max=[20, 255, 255],
morph=15,
blur=5,
text_output=False,
save=False)
self.pd.calibrate()
self.calibration_json.update({
'total_rotation_angle': 0.0,
'coord_scale': 1.7182,
'center_pixel_location': [465, 290]
})
self.objects = [{
'y': 300.69,
'x': 300.0,
'radius': 46.86
}, {
'y': 599.66,
'x': 897.94,
'radius': 46.86
}, {
'y': 800.68,
'x': 98.97,
'radius': 47.53
}]
def test_array_detect_simple(self):
"""Detect plants using simple array input"""
pd = PlantDetection(image='plant_detection/soil_image.jpg',
array=[{
'size': 5,
'kernel': 'ellipse',
'type': 'erode',
'iters': 2
}, {
'size': 3,
'kernel': 'ellipse',
'type': 'dilate',
'iters': 8
}],
text_output=False,
save=False)
pd.detect_plants()
object_count = 29
self.assertEqual(pd.plant_db.object_count, object_count)
def setUp(self):
self.calibration_json = {
"blur": 5,
"morph": 15,
"calibration_iters": 3,
"H": [160, 20],
"S": [100, 255],
"V": [100, 255],
"calibration_circles_xaxis": True,
"camera_offset_coordinates": [200, 100],
"image_bot_origin_location": [0, 1],
"calibration_circle_separation": 1000,
"invert_hue_selection": True
}
self.pd = PlantDetection(
image="plant_detection/p2c_test_objects.jpg",
calibration_img="plant_detection/p2c_test_calibration.jpg",
calibration_data=self.calibration_json,
HSV_min=[160, 100, 100],
HSV_max=[20, 255, 255],
morph=15,
blur=5,
text_output=False,
save=False)
self.pd.calibrate()
self.calibration_json.update({
"total_rotation_angle": 0.0,
"coord_scale": 1.7182,
"center_pixel_location": [465, 290]
})
self.objects = [{
'y': 300.69,
'x': 300.0,
'radius': 46.86
}, {
'y': 599.66,
'x': 897.94,
'radius': 46.86
}, {
'y': 800.68,
'x': 98.97,
'radius': 47.53
}]
