def restart_cam(cam_num):
cfile = "conf/config-" + cam_num + ".txt"
config = read_config(cfile)
url = "http://" + config[
'cam_ip'] + "/cgi-bin/restart_cgi?user=admin&pwd=" + config['cam_pwd']
print("RESTART: ", url)
r = requests.get(url)
def ping_cam(cam_num):
config = read_config("conf/config-" + str(cam_num) + ".txt")
cmd = "ping -c 1 " + config['cam_ip']
response = os.system(cmd)
if response == 0:
print ("Cam is up!")
return(1)
else:
print ("Cam is down!")
return(0)
def focus(config_file, cam_num):
config = {}
cv2.namedWindow('pepe')
config = read_config(config_file)
mask_file = "conf/mask-" + str(cam_num) + ".txt"
file_exists = Path(mask_file)
print("MASK FILE: ", mask_file)
mask_exists = 0
if (file_exists.is_file()):
print("File found.")
ms = open(mask_file)
for lines in ms:
line, jk = lines.split("\n")
exec(line)
ms.close()
#mask_exists = 1
#(sm_min_x, sm_max_x, sm_min_y, sm_max_y) = still_mask
#config['cam_ip'] = ip
cap = cv2.VideoCapture("rtsp://" + config['cam_ip'] + "/av0_0")
for fc in range(0, 10000):
_, frame = cap.read()
if frame is not None:
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frame[680:720, 0:620] = [0]
frame[580:720, 0:1280] = [0]
if mask_exists == 1:
frame[sm_min_y:sm_max_y, sm_min_x:sm_max_x] = [0]
max_px = np.amax(frame)
_, threshold = cv2.threshold(frame, max_px - 5, 255,
cv2.THRESH_BINARY)
(_, cnts, xx) = cv2.findContours(threshold.copy(),
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
if len(cnts) > 0:
x, y, w, h = cv2.boundingRect(cnts[0])
cv2.rectangle(frame, (x - 5, y - 5), (x + w + 5, y + h + 5),
(255), 1)
crop = frame[y - 20:y + 20, x - 20:x + 20]
_, crop_threshold = cv2.threshold(crop, max_px - 15, 255,
cv2.THRESH_BINARY)
#(_, cnts2, xx) = cv2.findContours(crop.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
#x,y,w,h = cv2.boundingRect(cnts2[0])
if (fc % 10 == 0):
print(w, h)
showme = cv2.resize(crop, (0, 0), fx=2.5, fy=2.5)
#showme = cv2.resize(frame, (0,0), fx=.5, fy=.5)
#showme = cv2.resize(threshold, (0,0), fx=.5, fy=.5)
cv2.imshow('pepe', showme)
cv2.waitKey(1)
def is_it_clear(cam_num):
# load the image
config = read_config("conf/config-" + str(cam_num) + ".txt")
image = get_cap(config)
avg_color_per_row = np.average(image, axis=0)
r, g, b = np.average(avg_color_per_row, axis=0)
if (100 < r < 145) and (100 < g < 145) and (100 < b < 145):
print(str(cam_num) + " Looks clear :)")
print(r, g, b)
else:
print(str(cam_num) + " Looks cloudy :(")
print(r, g, b)
def get_latest_pic(cam_num, cap_ip):
if cam_ip == "":
config_file = "conf/config-" + str(cam_num) + ".txt"
outfile = "/var/www/html/out/latest-" + str(cam_num) + ".jpg"
config = read_config(config_file)
else:
config = {}
config['cam_ip'] = cam_ip
el = cam_ip.split(".")
outfile = "/var/www/html/out/latest-" + str(el[-1]) + ".jpg"
cap = cv2.VideoCapture("rtsp://" + config['cam_ip'] + "/av0_0")
cv2.setUseOptimized(True)
_, frame = cap.read()
#frame = cv2.resize(frame, (0,0), fx=1, fy=.75)
cv2.imwrite(outfile, frame)
def setup_cam(cam):
if cam == '':
print ("ERROR NO CAM ID!")
exit()
else:
print ("Turning on cam# ", cam)
#os.system("./pizero-relay.py cam_on " + str(cam))
#time.sleep(15)
cont = input("Now is your time to focus. Press enter once done. ")
config = read_config()
cam_ip = "192.168.1.88"
# set the camera defaults, wait for reboot, then do it again
os.system("./camera_defaults.py " + cam_ip)
time.sleep(35)
os.system("./camera_defaults.py " + cam_ip)
os.system("./camera-settings.py " )
# get the mac address
file = open("caminfo/" + str(cam) + ".txt", "w")
url = "http://" + str(cam_ip) + "/cgi-bin/sysparam_cgi?user=admin&pwd="+ config['cam_pwd']
print (url)
r = requests.get(url)
lines = r.text.split("\n")
for line in lines:
if "MACAddress" in line:
file.write("<CamID>" + str(cam) + "</CamID>\n");
line = line.replace("\t", "");
file.write(line)
file.close()
# set boot proto to dhcp
url = "http://" + str(cam_ip) + "/cgi-bin/network_cgi?user=admin&pwd="+ config['cam_pwd'] + "&action=set&BootProto=dhcp"
print (url)
r = requests.get(url)
print (r.text)
def __init__(self, master):
self.master = master
print ("Cal class init")
# IMAGE FILE PATHS AND NAMES
self.image_path = None
self.wcs_path = None
self.man_sources = []
self.data_list = []
self.image = None
self.new_image = None
self.starmap_image = None
self.fireball_image = None
self.active_image = None
self.mask_on = None
self.mask_image = None
self.starlist_array = None
self.padding = 0
self.image_width = 640 + (self.padding * 2) # 840
self.image_height = 360 + (self.padding * 2) # 560
cam_num = 1
config_file = "/home/ams/fireball_camera/conf/config-" + str(cam_num) + ".txt"
config = read_config(config_file)
self.cal_time = None
self.obs_code = None
self.loc_lat = config['device_lat']
self.loc_lon = config['device_lng']
self.loc_alt = config['device_alt']
self.fb_dt = None
self.star_thresh = 7
self.odds_to_solve = 10000
self.code_tolerance = .3
# FRAME 1
# Build Calibration Layout
self.cal_frame1 = tk.Frame(self.master, borderwidth=1, bg='black', height=50, width=650)
# info at top of page
self.cal_frame1.pack_propagate(0)
self.button_open = tk.Button(self.cal_frame1, text="Open File", command=self.OpenImage)
self.button_open.pack(side=tk.LEFT)
self.button_set_location_time = tk.Button(self.cal_frame1, text='Set Loc/Time', command=self.button_set_location_time).pack(padx=1, pady=1, side=tk.LEFT)
self.filename_label_value = tk.StringVar()
self.filename_label = tk.Label(self.cal_frame1, textvariable=self.filename_label_value).pack(padx=1,pady=1,side=tk.LEFT)
self.filename_label_value.set("nofile2")
self.cal_time_label_value = tk.StringVar()
self.cal_time_label = tk.Label(self.cal_frame1, textvariable=self.cal_time).pack(padx=1,pady=1,side=tk.LEFT)
self.cal_time_label_value.set("No cal date set yet. ")
self.cal_frame1.pack(side=tk.TOP)
# FRAME 2
# image canvas
canvas_width = self.image_width
canvas_height = self.image_height
self.cal_frame2 = tk.Frame(self.master, bg='white', borderwidth=1, width=canvas_width+1, height=canvas_height+1, )
self.image_canvas = tk.Canvas(self.cal_frame2, width=canvas_width, height=canvas_height, cursor="cross")
self.image_canvas.extra = "image_canvas"
self.image_canvas.bind('<Motion>', self.motion)
self.image_canvas.pack()
self.cal_frame2.extra = 'image_canvas_frame'
self.image_canvas.bind('<Button-1>', self.mouseClick)
self.image_canvas.bind('<Button-3>', self.mouseRightClick)
self.cal_frame2.pack(side=tk.TOP)
# FRAME 3 - Action Buttons
self.cal_frame3 = tk.Frame(self.master, bg='blue', height=50, width=self.image_width)
self.cal_frame3_unsolved()
self.cal_frame3.pack(side=tk.TOP)
self.cal_frame3.pack_propagate(0)
# FRAME 4
self.cal_frame4 = tk.Frame(self.master, bg='blue', height=300, width=self.image_width)
self.container_far_left = tk.Frame(self.cal_frame4)
self.fcfl = tk.Frame(self.container_far_left)
self.star_thresh_label = tk.Label(self.fcfl, text="Star Threshold" ).pack(padx=1,pady=1,side=tk.TOP)
self.e1 = tk.Entry(self.fcfl, textvariable=self.star_thresh)
self.e1.insert(0, self.star_thresh)
self.e1.pack()
self.fcfl.pack(side=tk.TOP)
self.fcfl2 = tk.Frame(self.container_far_left)
self.odds_to_solve_label = tk.Label(self.fcfl2, text="Odds To Solve" ).pack(padx=1,pady=1,side=tk.TOP)
self.e2 = tk.Entry(self.fcfl2, textvariable=self.odds_to_solve)
self.e2.insert(0, self.odds_to_solve)
self.e2.pack(side=tk.TOP)
self.fcfl2.pack(side=tk.TOP)
self.fcfl3 = tk.Frame(self.container_far_left)
self.code_tolerance = tk.Label(self.fcfl2, text="Code Tolerance" ).pack(padx=1,pady=1,side=tk.TOP)
self.e3 = tk.Entry(self.fcfl3, textvariable=self.code_tolerance)
self.e3.insert(0, ".3")
self.e3.pack(side=tk.TOP)
self.fcfl3.pack(side=tk.TOP)
self.container_far_left.pack(side=tk.LEFT)
self.container_left = tk.Frame(self.cal_frame4)
# Sliders
self.field_container = tk.Frame(self.container_left)
self.brightness_label = tk.Label(self.field_container, text="Brightness" ).pack(padx=1,pady=1,side=tk.TOP)
self.brightness_slider = tk.Scale(self.field_container, from_=-100, to=100, orient=tk.HORIZONTAL, command=self.updateBrightness).pack(padx=1, pady=1, side=tk.BOTTOM)
self.field_container.pack(side=tk.TOP)
self.field_container2 = tk.Frame(self.container_left)
contrast_label = tk.Label(self.field_container2, text="Contrast" ).pack(padx=1, pady=1, side=tk.TOP)
contrast_slider = tk.Scale(self.field_container2, from_=-100, to=100, orient=tk.HORIZONTAL, command=self.updateContrast ).pack(padx=1, pady=1, side=tk.BOTTOM)
self.field_container2.pack(side=tk.TOP)
self.container_left.pack(side=tk.LEFT)
# Middle Container
self.container_middle = tk.Frame(self.cal_frame4)
self.xy_label_value = tk.StringVar()
self.xy_label_value.set("x,y,fa,bp")
self.xy_label= tk.Label(self.container_middle, textvariable=self.xy_label_value).pack(padx=1,pady=1,side=tk.TOP)
self.ra_label_value = tk.StringVar()
self.ra_label_value.set("ra,dec")
self.ra_label= tk.Label(self.container_middle, textvariable=self.ra_label_value).pack(padx=1,pady=1,side=tk.TOP)
self.az_label_value = tk.StringVar()
self.az_label_value.set("alt,az")
self.az_label= tk.Label(self.container_middle, textvariable=self.az_label_value).pack(padx=1,pady=1,side=tk.TOP)
self.container_middle.pack(side=tk.LEFT)
# Right side container!
self.container_right = tk.Frame(self.cal_frame4)
self.thumbnail_canvas = tk.Canvas(self.container_right, width=100, height=100, cursor="cross")
self.thumbnail_canvas.extra = "thumbnail_canvas"
self.thumbnail_canvas.pack()
self.container_right.pack(side=tk.LEFT)
self.del_button = tk.Button(self.cal_frame4, text='Delete File', command=self.button_delete).pack(padx=1, pady=1, side=tk.LEFT)
self.exit_button = tk.Button(self.cal_frame4, text='Exit', command=root.destroy).pack(padx=1, pady=1, side=tk.BOTTOM)
self.cal_frame4.pack_propagate(0)
self.cal_frame4.pack(side=tk.TOP)
def diff_stills(sdate, cam_num):
med_last_objects = []
last_objects = deque(maxlen=5)
diffed_files = []
config = read_config("conf/config-1.txt")
video_dir = "/mnt/ams2/SD/"
images = []
images_orig = []
images_blend = []
images_info = []
count = 0
last_image = None
last_thresh_sum = 0
hits = 0
avg_cnt = 0
avg_tot = 0
avg_pts = 0
count = 0
glob_dir = video_dir + "proc/" + sdate + "/" + "*cam" + str(
cam_num) + "-stacked.jpg"
report_file = video_dir + "proc/" + sdate + "/" + sdate + "-cam" + str(
cam_num) + "-report.txt"
master_stack_file = video_dir + "proc/" + sdate + "/" + sdate + "-cam" + str(
cam_num) + "-master_stack.jpg"
#cv2.namedWindow('pepe')
mask_file = "conf/mask-" + str(cam_num) + ".txt"
file_exists = Path(mask_file)
mask_exists = 0
still_mask = [0, 0, 0, 0]
if (file_exists.is_file()):
print("File found.")
ms = open(mask_file)
for lines in ms:
line, jk = lines.split("\n")
exec(line)
ms.close()
mask_exists = 1
(sm_min_x, sm_max_x, sm_min_y, sm_max_y) = still_mask
diffs = 0
image_list = []
file_list = []
sorted_list = []
print("Loading still images from ", glob_dir)
fp = open(report_file, "w")
for filename in (glob.glob(glob_dir)):
capture_date = parse_file_date(filename)
sun_status, sun_alt = day_or_night(config, capture_date)
if sun_status != 'day' and int(sun_alt) <= -5:
#print("NIGHTTIME", capture_date, filename, sun_status)
file_list.append(filename)
else:
print("This is a daytime or dusk file")
sorted_list = sorted(file_list)
for filename in sorted_list:
open_cv_image = cv2.imread(filename, 0)
orig_image = open_cv_image
images_orig.append(orig_image)
print(filename)
open_cv_image[440:480, 0:640] = [0]
if mask_exists == 1:
open_cv_image[sm_min_y:sm_max_y, sm_min_x:sm_max_x] = [0]
images.append(open_cv_image)
#exit()
#time.sleep(5)
height, width = open_cv_image.shape
master_stack = None
# Define the codec and create VideoWriter object
#fourcc = cv2.VideoWriter_fourcc(*'H264')
#out = cv2.VideoWriter(outfile,fourcc, 5, (width,height),1)
#med_stack_all = np.median(np.array(images[50:150]), axis=0)
med_stack_all = np.median(np.array(images), axis=0)
#cv2.imshow('pepe', cv2.convertScaleAbs(med_stack_all))
#cv2.waitKey(1000)
objects = None
last_line_groups = []
last_points = []
for filename in sorted_list:
hit = 0
detect = 0
el = filename.split("/")
fn = el[-1]
#this_image = cv2.imread(filename,1)
this_image = images[count]
if count >= 1:
before_image = images[count - 1]
else:
before_image = images[count + 2]
if count >= len(file_list) - 1:
after_image = images[count - 2]
else:
after_image = images[count + 1]
if count < 25:
median = np.median(np.array(images[0:count + 25]), axis=0)
elif len(images) - count < 25:
median = np.median(np.array(images[count - 25:count]), axis=0)
else:
median = np.median(np.array(images[count - 25:count]), axis=0)
if count < 10:
background = images[count + 1]
for i in range(0, 10):
background = cv2.addWeighted(background, .8, images[count + i],
.2, 0)
else:
background = images[count - 1]
for i in range(0, 10):
background = cv2.addWeighted(background, .8, images[count - i],
.2, 0)
img_rpt_file = filename.replace("-stacked.jpg", "-stack-report.txt")
img_report = open(img_rpt_file, "w")
(blend, points, line_groups, stars, obj_points,
big_cnts) = inspect_image(med_stack_all, background, median,
before_image, this_image, after_image,
avg_cnt, avg_tot, avg_pts, filename)
master_stack = stack_stack(blend, master_stack)
img_report.write("points=" + str(points) + "\n")
img_report.write("line_groups=" + str(line_groups) + "\n")
img_report.write("stars=" + str(stars) + "\n")
img_report.write("obj_points=" + str(obj_points) + "\n")
img_report.write("big_cnts=" + str(big_cnts) + "\n")
img_report.close()
images_blend.append(blend)
images_info.append((points, line_groups, stars, obj_points, big_cnts))
# block out the detections in the master image to remove it from the running mask
last_line_group = line_groups
last_points = points
for x, y, w, h in last_points:
images[count][y:y + h, x:x + w] = 5
count = count + 1
if len(big_cnts) > 0 or len(obj_points) >= 3:
hits = hits + 1
#cv2.imshow('pepe', blend)
#if len(line_groups) >= 1 or len(obj_points) > 3 or len(big_cnts) > 0:
#cv2.waitKey(1)
# while(1):
# k = cv2.waitKey(33)
# if k == 32:
# break
# if k == 27:
# exit()
#else:
#cv2.waitKey(1)
data = filename + "," + str(len(line_groups)) + "," + str(
len(obj_points)) + "," + str(len(big_cnts)) + "\n"
fp.write(data)
print("TOTAL: ", len(file_list))
print("HITS: ", hits)
fp.close()
if master_stack is not None:
print("saving", master_stack_file)
master_stack.save(master_stack_file, "JPEG")
else:
print("Failed.")
hits = 1
for count in range(0, len(sorted_list) - 1):
file = sorted_list[count]
el = file.split("/")
st = el[-1]
report_str = st.replace("-stacked.jpg", "-report.txt")
video_str = st.replace("-stacked.jpg", ".mp4")
video_file = file.replace("-stacked.jpg", ".mp4")
(points, line_groups, stars, obj_points, big_cnts) = images_info[count]
if len(obj_points) > 3 or len(big_cnts) > 0:
for bc in big_cnts:
(x, y, w, h) = bc
obj_points.append((x, y, 5, 5))
obj_points.append((x + w, y + h, 5, 5))
np_obj_points = np.array(obj_points)
max_x = np.max(np_obj_points[:, 0])
max_y = np.max(np_obj_points[:, 1])
min_x = np.min(np_obj_points[:, 0])
min_y = np.min(np_obj_points[:, 1])
myimg = cv2.imread(sorted_list[count], 0)
cv2.rectangle(myimg, (min_x, min_y), (max_x, max_y), (255), 1)
#cv2.imshow('pepe', myimg)
#cv2.waitKey(1)
print("-------")
print("Count:", count)
print("Hit:", hits)
print("File:", sorted_list[count])
print("Points:", str(len(points)))
print("Line Groups:", str(len(line_groups)))
gc = 1
for line_group in line_groups:
for dist, ang, x1, y1, w1, h1 in line_group:
print("GROUP: ", gc, dist, ang, x1, y1, w1, h1)
gc = gc + 1
print("Stars:", str(len(stars)))
print("Obj Points:", str(len(obj_points)))
print("Big Cnts:", str(len(big_cnts)))
print("Min/Max X/Y:", str(min_x), str(min_y), str(max_x),
str(max_y))
print("-------")
hits = hits + 1
video_report = video_file.replace(".mp4", "-report.txt")
file_exists = Path(video_report)
if (file_exists.is_file()):
print("Already processed the video.")
#else:
# print("./PV.py " + video_file + " " + cam_num)
# os.system("./PV.py " + video_file + " " + cam_num)
else:
min_x = min_y = max_x = max_y = 0
def view(file, show = 0):
# before processing dump frames from this file for 24 hour time lapse
os.system("./dump-frames-tl.py " + file )
config_file = ""
try:
(file_date, cam_num) = file.split("-")
cam_num = cam_num.replace(".avi", "")
except:
cam_num = ""
if cam_num == "":
config = read_config(config_file)
else:
#cam_num = sys.argv[1]
config_file = "conf/config-" + cam_num + ".txt"
config = read_config(config_file)
#config = read_config(config_file)
frame_time_data = []
values = {}
dir_name = os.path.dirname(file)
file_name = file.replace(dir_name + "/", "")
summary_file_name = file_name.replace(".avi", "-summary.txt")
data_file_name = file_name.replace(".avi", ".txt")
screen_cap_file_name = file_name.replace(".avi", ".jpg")
object_file_name = file_name.replace(".avi", "-objects.jpg")
time_file_name = file_name.replace(".avi", "-time.txt")
capture_date = parse_file_date(file_name)
#last_cal_date = # Get last / closest calibration date
file_base_name = file_name.replace(".avi", "")
status = day_or_night(config, capture_date)
# read in time file if it exists
if os.path.isfile(dir_name + "/" + time_file_name):
frame_time_data = read_time_file(dir_name + "/" + time_file_name)
print ("FRAME TIME DATA LENGTH:", len(frame_time_data))
time.sleep(1)
else:
print ("no frame time data! " + dir_name + "/" + time_file_name )
for x in range(0, 225):
frame_time_data.append("|||")
fps_t = 0
for ftd in frame_time_data:
print ("FRAMEdata", ftd)
fps, tc, tt, tx = ftd.split("|")
if fps == "":
fps = 0
fps_t = int(float(fps_t)) + int(float(fps))
if len(frame_time_data) > 0:
avg_fps = fps_t / len(frame_time_data)
else :
avg_fps = 0
print ("Viewing file: " + file)
print ("Directory: " + dir_name)
print ("File Name: " + file_name)
print ("Summary File Name: " + summary_file_name)
print ("Data File Name: " + data_file_name)
print ("Screen Cap File Name: " + screen_cap_file_name)
print ("Object File Name: " + object_file_name)
print ("Capture Date: " + capture_date)
print ("FPS: " + str(avg_fps))
# make sure the file exists
if os.path.isfile(file) is False:
print("This file does not exist. Exiting.")
return(0)
else:
print ("The file is ok.")
#process video
tstamp_prev = None
image_acc = None
last_frame = None
nice_image_acc = None
final_image = None
cur_image = None
frame_count = 0
# open data log file
fp = open(dir_name + "/" + data_file_name, "w")
fp2 = open(dir_name + "/" + summary_file_name, "w")
fp.write("frame|contours|x|y|w|h|color|fps|adjusted_unixtime|unixtime|time_offset\n")
fp2.write("frame|contours|x|y|w|h|color|fps|adjusted_unixtime|unixtime|time_offset\n")
#if show == 1:
# cv2.namedWindow('pepe')
cap = cv2.VideoCapture(file)
time.sleep(2)
xs = []
ys = []
motion_frames = []
frames = []
colors = []
noise = 0
while True:
_ , frame = cap.read()
frame_count = frame_count + 1
frames.extend([frame])
if frame is None:
if frame_count <= 1:
print("Bad file.")
return(0)
else:
print("Processed ", frame_count, "frames.")
# finish processing file and write output files
total_motion = len(motion_frames)
if total_motion < 3 :
#this a BS capture. abort
os.system("mv " + dir_name + "/" + file_base_name + "* " + "/var/www/html/out/dist/")
return(0)
half_motion = int(round(total_motion/2,0))
print ("key frame #1 : ", 1)
print ("key frame #2 : ", half_motion)
print ("key frame #3 : ", total_motion -1)
print ("Xs", xs)
print ("Ys", ys)
print ("MF", motion_frames)
avg_color = sum(colors) / float(len(colors))
print ("CL", colors)
print ("Avg Color: ", avg_color)
#print (motion_frames[1])
#print (motion_frames[half_motion])
#print (motion_frames[total_motion -1])
#print(frames[motion_frames[1]])
#print(frames[motion_frames[half_motion]])
#print(frames[motion_frames[total_motion - 1]])
object_file_image = (frames[motion_frames[1]] * .33) + (frames[motion_frames[half_motion]] * .33) + (frames[motion_frames[total_motion-2]] * .33)
x1 = xs[1]
y1 = xs[1]
x2 = xs[half_motion]
y2 = xs[half_motion]
x3 = xs[total_motion-2]
y3 = xs[total_motion-2]
xmax = max(xs)
ymax = max(ys)
xmin = min(xs)
ymin = min(ys)
skip = 0
if xmax - xmin == 0 and ymax - ymin == 0:
skip = 1
straight_line = compute_straight_line(x1,y1,x2,y2,x3,y3)
if (straight_line < 1 and straight_line > 0) or avg_color > 190:
meteor_yn = "Y"
else:
meteor_yn = "N"
if status == 'night':
meteor_yn = "Y"
else:
meteor_yn = "N"
#meteor_yn = "Y"
if skip == 1:
meteor_yn = "N"
print ("Skipping not enough x,y movement!", xmax, xmin, ymax, ymin)
if noise >= 5:
meteor_yn = "N"
print ("Skipping to much noise!", noise)
if avg_fps < 20:
meteor_yn = "N"
print ("Skipping calibration file!", avg_fps)
print ("Status:", status)
print ("Straight Line:", straight_line)
print ("Likely Meteor:", meteor_yn)
obj_outfile = dir_name + "/" + object_file_name
sc_outfile = dir_name + "/" + screen_cap_file_name
cv2.imwrite(obj_outfile, object_file_image)
cv2.imwrite(sc_outfile, object_file_image)
#write summary & data files
fp.close()
fp2.close()
# prep event or capture for upload to AMS
values['datetime'] = capture_date
values['motion_frames'] = total_motion
values['cons_motion'] = total_motion
values['color'] = avg_color
values['straight_line'] = straight_line
values['meteor_yn'] = meteor_yn
values['bp_frames'] = total_motion
if meteor_yn == 'Y':
try:
values['best_caldate'] = config['best_caldate']
except:
config['best_caldate'] = '0000-00-00 00:00:00';
values['best_caldate'] = config['best_caldate']
try:
log_fireball_event(config, file, dir_name + "/" + summary_file_name, dir_name + "/" + object_file_name, values)
except:
print ("failed to upload event file.")
return(0)
#move files to maybe dir
print ("Move to maybe dir!")
os.system("mv " + dir_name + "/" + file_base_name + "* " + "/var/www/html/out/maybe/")
else:
log_motion_capture(config, dir_name + "/" + object_file_name, values)
try:
log_motion_capture(config, dir_name + "/" + object_file_name, values)
except:
print ("failed to upload capture file.")
return(0)
print ("Move to false dir!")
if (skip == 1 or noise >= 5) and status == 'night':
os.system("mv " + dir_name + "/" + file_base_name + "* " + "/var/www/html/out/dist/")
elif avg_fps < 20:
os.system("mv " + dir_name + "/" + file_base_name + "* " + "/var/www/html/out/calvid/")
else:
os.system("mv " + dir_name + "/" + file_base_name + "* " + "/var/www/html/out/false/")
return(1)
nice_frame = frame
alpha, tstamp_prev = iproc.getAlpha(tstamp_prev)
frame = cv2.resize(frame, (0,0), fx=0.5, fy=0.5)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray_frame = frame
frame = cv2.GaussianBlur(frame, (21, 21), 0)
if last_frame is None:
last_frame = nice_frame
if image_acc is None:
image_acc = np.empty(np.shape(frame))
image_diff = cv2.absdiff(image_acc.astype(frame.dtype), frame,)
hello = cv2.accumulateWeighted(frame, image_acc, alpha)
_, threshold = cv2.threshold(image_diff, 30, 255, cv2.THRESH_BINARY)
thresh= cv2.dilate(threshold, None , iterations=2)
(_, cnts, xx) = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
data = str(frame_count) + "|"
color = 0
contours = len(cnts)
x,y,w,h = 0,0,0,0
if contours > 3:
noise = noise + 1
if contours > 0:
x,y,w,h = cv2.boundingRect(cnts[0])
mx = x + w
my = y + h
cx = int(x + (w/2))
cy = int(y + (h/2))
color = gray_frame[cy,cx]
xs.extend([x])
ys.extend([y])
colors.extend([color])
motion_frames.extend([frame_count])
line_data = str(frame_count) + "|" + str(contours) + "|" + str(x) + "|" + str(y) + "|" + str(w) + "|" + str(h) + "|" + str(color) + "|" + frame_time_data[frame_count-1] + "\n"
fp.write(line_data)
fp2.write(line_data)
print (frame_count, contours, x,y,w,h,color)
date_dir = "/mnt/ams2/SD/proc/" + xyear + "-" + xmonth + "-" + xday
file_exists = Path(date_dir)
skip = 0
if (file_exists.is_dir() is False):
os.system("mkdir " + date_dir)
if sun_status == "day":
cmd = "mv " + file + " /mnt/ams2/SD/proc/daytime/" + file_name
print(cmd)
os.system(cmd)
cmd = "mv " + video_file + " /mnt/ams2/SD/proc/daytime/" + video_file_name
print(cmd)
os.system(cmd)
else:
if "-stacked" not in file_name:
file_name = file_name.replace("stack", "stacked")
cmd = "mv " + file + " " + date_dir + "/" + file_name
print(cmd)
os.system(cmd)
cmd = "mv " + video_file + " " + date_dir + "/" + video_file_name
print(cmd)
os.system(cmd)
conf = read_config("conf/config-1.txt")
purge_hd_files()
purge_sd_files()
move_processed_SD_files()
purge_SD_proc_dir()
def get_calibration_frames():
config = read_config()
config = custom_settings("Calibration", config)
fp = open("/home/pi/fireball_camera/calnow", "w")
set_setting(config, "Brightness", config['Brightness'])
r = requests.get(
"http://" + config['cam_ip'] +
"/webs/btnSettingEx?flag=1000¶mchannel=0¶mcmd=1058¶mctrl=25¶mstep=0¶mreserved=0&"
)
cap = cv2.VideoCapture("rtsp://" + config['cam_ip'] + "/av0_1")
cv2.setUseOptimized(True)
lock = open("/home/pi/fireball_camera/calibrate.txt", "w")
time_start = time.time()
time.sleep(3)
frames = deque(maxlen=200)
frame_times = deque(maxlen=200)
count = 0
while count < 301:
_, frame = cap.read()
if _ is True:
if count > 100:
frame_time = time.time()
frames.appendleft(frame)
frame_times.appendleft(frame_time)
if count == 300:
dql = len(frame_times) - 1
time_diff = frame_times[1] - frame_times[dql]
fps = 100 / time_diff
format_time = datetime.datetime.fromtimestamp(
int(frame_time)).strftime("%Y%m%d%H%M%S")
outfile = "{}/{}.avi".format("/var/www/html/out/cal", format_time)
if int(config['hd']) == 0:
frame_sz = cv2.resize(frames[0], (0, 0), fx=1, fy=.75)
else:
frame_sz = frames[0]
writer = cv2.VideoWriter(outfile, cv2.VideoWriter_fourcc(*'MJPG'),
fps,
(frame_sz.shape[1], frame_sz.shape[0]),
True)
flc = 0
while frames:
if (flc > 30):
img = frames.pop()
if int(config['hd']) == 0:
frame_sz = cv2.resize(img, (0, 0), fx=1, fy=.75)
else:
frame_sz = img
img = frame_sz
frame_time = frame_times.pop()
format_time = datetime.datetime.fromtimestamp(
int(frame_time)).strftime("%Y%m%d%H%M%S")
dec_sec = datetime.datetime.fromtimestamp(
int(frame_time)).strftime("%f")
format_time = format_time + dec_sec
writer.write(img)
flc = flc + 1
writer.release()
count = count + 1
# sense camera down
r = requests.get(
"http://" + config['cam_ip'] +
"/webs/btnSettingEx?flag=1000¶mchannel=0¶mcmd=1058¶mctrl=50¶mstep=0¶mreserved=0&"
)
config = custom_settings("Night", config)
set_setting(config, "Brightness", config['Brightness'])
cap.release()
time.sleep(3)
os.system("rm /home/pi/fireball_camera/calnow")
return (outfile)
def diff_stills(sdate, cam_num):
med_last_objects = []
last_objects = deque(maxlen=5)
diffed_files = []
config = read_config("conf/config-1.txt")
video_dir = "/mnt/ams2/SD/"
images = []
count = 0
last_image = None
last_thresh_sum = 0
hits = 0
avg_cnt = 0
avg_tot = 0
avg_pts = 0
count = 0
glob_dir = video_dir + "proc/" + sdate + "/" + "*cam" + str(
cam_num) + "-stacked.jpg"
report_file = video_dir + "proc/" + sdate + "/" + sdate + "-cam" + str(
cam_num) + "-report.txt"
cv2.namedWindow('pepe')
mask_file = "conf/mask-" + str(cam_num) + ".txt"
file_exists = Path(mask_file)
mask_exists = 0
if (file_exists.is_file()):
print("File found.")
ms = open(mask_file)
for lines in ms:
line, jk = lines.split("\n")
exec(line)
ms.close()
mask_exists = 1
(sm_min_x, sm_max_x, sm_min_y, sm_max_y) = still_mask
diffs = 0
image_list = []
file_list = []
sorted_list = []
print("Loading still images from ", glob_dir)
fp = open(report_file, "w")
for filename in (glob.glob(glob_dir)):
capture_date = parse_file_date(filename)
sun_status = day_or_night(config, capture_date)
if sun_status != 'day':
#print("NIGHTTIME", capture_date, filename, sun_status)
file_list.append(filename)
sorted_list = sorted(file_list)
for filename in sorted_list:
open_cv_image = cv2.imread(filename, 0)
open_cv_image[440:480, 0:640] = [0]
if mask_exists == 1:
open_cv_image[sm_min_y:sm_max_y, sm_min_x:sm_max_x] = [0]
images.append(open_cv_image)
#exit()
#time.sleep(5)
height, width = open_cv_image.shape
# Define the codec and create VideoWriter object
#fourcc = cv2.VideoWriter_fourcc(*'H264')
#out = cv2.VideoWriter(outfile,fourcc, 5, (width,height),1)
#med_stack_all = np.median(np.array(images[50:150]), axis=0)
med_stack_all = np.median(np.array(images), axis=0)
#cv2.imshow('pepe', cv2.convertScaleAbs(med_stack_all))
#cv2.waitKey(1000)
objects = None
last_line_groups = []
last_points = []
for filename in sorted_list:
hit = 0
detect = 0
el = filename.split("/")
fn = el[-1]
#this_image = cv2.imread(filename,1)
this_image = images[count]
if count >= 1:
before_image = images[count - 1]
else:
before_image = images[count + 2]
if count >= len(file_list) - 1:
after_image = images[count - 2]
else:
after_image = images[count + 1]
if count < 25:
median = np.median(np.array(images[0:count + 25]), axis=0)
elif len(images) - count < 25:
median = np.median(np.array(images[count - 25:count]), axis=0)
else:
median = np.median(np.array(images[count - 25:count]), axis=0)
if count < 10:
background = images[count + 1]
for i in range(0, 10):
background = cv2.addWeighted(background, .8, images[count + i],
.2, 0)
else:
background = images[count - 1]
for i in range(0, 10):
background = cv2.addWeighted(background, .8, images[count - i],
.2, 0)
result, line_groups, points = inspect_image(med_stack_all, background,
median, before_image,
this_image, after_image,
avg_cnt, avg_tot, avg_pts,
filename)
# block out the detections in the master image to remove it from the running mask
last_line_group = line_groups
last_points = points
for x, y, w, h in last_points:
images[count][y:y + h, x:x + w] = 5
count = count + 1
hits = hits + result
print("TOTAL: ", len(file_list))
print("DIFFS: ", diffs)
print("HITS: ", hits)
fp.close()
for file in diffed_files:
el = file.split("/")
st = el[-1]
report_str = st.replace("-stack.jpg", "-report.txt")
video_str = st.replace("-stack.jpg", ".mp4")
def diff_stills(sdate, cam_num, show_video):
med_last_objects = []
last_objects = deque(maxlen=5)
diffed_files = []
config = read_config("conf/config-1.txt")
video_dir = "/mnt/ams2/SD/"
images = []
images_orig = []
images_blend = []
images_info = []
count = 0
last_image = None
last_thresh_sum = 0
hits = 0
avg_cnt = 0
avg_tot = 0
avg_pts = 0
count = 0
glob_dir = video_dir + "proc/" + sdate + "/" + "*cam" + str(cam_num) + "-stacked.jpg"
report_file = video_dir + "proc/" + sdate + "/" + sdate + "-cam" + str(cam_num) + "-report.txt"
master_stack_file = video_dir + "proc/" + sdate + "/" + sdate + "-cam" + str(cam_num) + "-master_stack.jpg"
if int(show_video) == 1:
cv2.namedWindow('pepe')
mask_file = "conf/mask-" + str(cam_num) + ".txt"
file_exists = Path(mask_file)
mask_exists = 0
still_mask = [0,0,0,0]
if (file_exists.is_file()):
print("File found.")
ms = open(mask_file)
for lines in ms:
line, jk = lines.split("\n")
exec(line)
ms.close()
mask_exists = 1
(sm_min_x, sm_max_x, sm_min_y, sm_max_y) = still_mask
diffs = 0
image_list = []
file_list = []
sorted_list = []
print ("Loading still images from ", glob_dir)
for filename in (glob.glob(glob_dir)):
capture_date = parse_file_date(filename)
sun_status, sun_alt = day_or_night(config, capture_date)
#if sun_status != 'day' and int(sun_alt) < -4:
#if sun_status != 'day' :
#print("NIGHTTIME", capture_date, filename, sun_status)
file_list.append(filename)
#else:
# print ("This is a daytime or dusk file")
sorted_list = sorted(file_list)
print ("Loading Images...")
print ("TOTAL IMAGES TO START:", len(sorted_list))
#time.sleep(5)
for filename in sorted_list:
open_cv_image = cv2.imread(filename,0)
orig_image = open_cv_image
images_orig.append(orig_image)
print(filename)
#open_cv_image[440:480, 0:640] = [0]
#if mask_exists == 1:
# open_cv_image[sm_min_y:sm_max_y, sm_min_x:sm_max_x] = [0]
if open_cv_image is not None:
if len(open_cv_image.shape) > 2:
open_cv_image = cv2.cvtColor(open_cv_image, cv2.COLOR_BGR2GRAY)
images.append(open_cv_image)
else:
print ("IMAGE IS BAD!")
cmd = "rm " + filename
os.system(cmd)
print ("Finished Loading Images.")
height , width = open_cv_image.shape
master_stack = None
print ("Make master median...")
#med_stack_all = np.median(np.array(images), axis=0)
print ("Done master median...")
objects = None
last_line_groups = []
last_points = []
for filename in sorted_list:
hit = 0
detect = 0
el = filename.split("/")
fn = el[-1]
this_image = images[count]
blend_file = filename.replace('stacked', 'blend')
file_exists = Path(blend_file)
if (file_exists.is_file()):
blend = cv2.imread(blend_file)
print ("We already did this. Skip", filename)
print (blend.shape)
capture_date = parse_file_date(fn)
sun_status, sun_alt = day_or_night(config, capture_date)
if int(sun_alt) < -17:
print("SUN: ", sun_alt)
master_stack = stack_stack(blend, master_stack)
if int(show_video) == 1:
cv2.imshow('pepe', blend)
cv2.waitKey(10)
else:
if count >= 1:
before_image = images[count-1]
else:
before_image = images[count+2]
if count >= len(file_list)-1:
after_image = images[count-2]
else:
after_image = images[count+1]
if count < 50:
median = np.median(np.array(images[0:count+50]), axis=0)
elif len(images) - count < 50:
median = np.median(np.array(images[count-50:count]), axis=0)
else:
median = np.median(np.array(images[count-50:count]), axis=0)
#image_diff = cv2.absdiff(image_acc.astype(frame.dtype), frame,)
if count < 15:
background = images[count+1]
for i in range (0,15):
background = cv2.addWeighted(background, .94, images[count+i], .06,0)
else:
background = images[count-1]
for i in range (0,15):
background = cv2.addWeighted(background, .94, images[count-i], .06,0)
img_rpt_file = filename.replace("-stacked.jpg", "-stack-report.txt")
#img_report = open(img_rpt_file, "w")
current_image = this_image
image_diff = cv2.absdiff(current_image.astype(current_image.dtype), background,)
orig_image = current_image
#current_image = image_diff
print ("working on: ", filename)
blend, current_image, filename = diff_all(None, background, median, before_image, current_image, after_image,filename)
blend_file = filename.replace('stacked', 'blend')
cv2.imwrite(blend_file, blend)
#cv2.imshow('pepe', blend)
#cv2.waitKey(1)
count = count + 1
capture_date = parse_file_date(fn)
sun_status, sun_alt = day_or_night(config, capture_date)
if int(sun_alt) < -17:
master_stack = stack_stack(blend, master_stack)
if master_stack is not None:
print("saving", master_stack_file)
master_stack.save(master_stack_file, "JPEG")
else:
print("Failed to save master stack.")
file_list.append(filename)
count = count + 1
report = report + " " + str(count) + " distorton captures\n"
report = report + "--------------------------\n"
return (report)
cur_time = int(time.time())
yest_time = int(time.time() - 86400)
stop_time = datetime.datetime.fromtimestamp(
int(cur_time)).strftime("%Y-%m-%d %H:%M:%S")
start_time = datetime.datetime.fromtimestamp(
int(yest_time)).strftime("%Y-%m-%d %H:%M:%S")
try:
config = read_config("conf/config-1.txt")
single = 0
except:
config = read_config("config.txt")
cam_num = config['cam_num']
single = 1
report = "AllSky6 24 Hour Report for " + config['obs_name'] + "\n"
report = report + "Period:" + str(start_time) + " to " + str(stop_time) + "\n"
report = report + "Camera Operator: " + config['first_name'] + " " + config[
'last_name'] + "\n"
report = report + "Latitude : " + config['device_lat'] + "\n"
report = report + "Longitude: " + config['device_lng'] + "\n"
report = report + "Altitude: " + config['device_alt'] + "\n"
if single == 0:
from view import log_motion_capture
from amscommon import read_config, caldate
values = {}
values['datetime'] = "2017-06-22 13:27:58"
values['motion_frames'] = 2
values['cons_motion'] = 2
values['color'] = 1
values['straight_line'] = 1
values['meteor_yn'] = 0
values['bp_frames'] = 3
log_motion_capture(read_config(), "./test_data/20170622132758.jpg", values)
def calibrate_file(image_path):
padding = 100
image_np = cv2.imread(image_path)
image = Image.fromarray(image_np)
new_image = image
ow = image_np.shape[1]
oh = image_np.shape[0]
image_width = ow + padding
image_height = oh + padding
if (ow != image_width and oh != image_height):
canvas_size = oh + padding, ow + padding, 3
canvas = np.zeros(canvas_size, dtype=np.uint8)
canvas.fill(0)
canvas[padding:oh + padding, padding:ow + padding] = image_np
image_np = canvas
image = Image.fromarray(image_np)
new_image = image
cv2.imwrite(image_path, image_np)
image_np = cv2.imread(image_path)
image = Image.fromarray(image_np)
new_image = image
cal_obj.image = cv2.imread(image_path)
cal_obj.image = Image.fromarray(cal_obj.image)
cal_obj.new_image = cal_obj.image
cal_obj.star_thresh = 5
cal_obj.find_stars()
cal_obj.image_width = image_np.shape[1]
cal_obj.image_height = image_np.shape[0]
# load site and date here...
config = read_config("conf/config-1.txt")
cal_obj.loc_lat = config['device_lat']
cal_obj.loc_lon = config['device_lng']
cal_obj.loc_alt = config['device_alt']
cal_obj.cal_time = cal_obj.parse_file_date(image_path)
cal_obj.odds_to_solve = 100000
odds = 100000
cal_obj.code_tolerance = .03
cal_obj.update_path(image_path)
cal_obj.solve_field()
if cal_obj.solve_success == 0:
odds = 10000
cal_obj.odds_to_solve = 10000
cal_obj.solve_field()
if cal_obj.solve_success == 0:
odds = 1000
cal_obj.odds_to_solve = 1000
cal_obj.solve_field()
if cal_obj.solve_success == 0:
odds = 100
cal_obj.odds_to_solve = 100
cal_obj.solve_field()
return (cal_obj.solve_success, odds)
def view(file, show=0):
nostars = 0
skip = 0
avg_color = 0
max_cons_motion = 0
straight_line = -1
final_image = None
start_time = int(time.time())
el = file.split("/")
act_file = el[-1]
dir = file.replace(act_file, "")
acc_file = act_file.replace(".mp4", "-acc.jpg")
star_file = act_file.replace(".mp4", "-stars.jpg")
acc_file = dir + "stars/" + acc_file
star_file = dir + "stars/" + star_file
# before processing dump frames from this file for 24 hour time lapse
#os.system("./dump-frames-tl.py " + file )
config_file = ""
try:
(file_date, cam_num) = file.split("-")
cam_num = cam_num.replace(".avi", "")
except:
cam_num = ""
if cam_num == "":
config = read_config(config_file)
else:
#cam_num = sys.argv[1]
config_file = "conf/config-" + cam_num + ".txt"
config = read_config(config_file)
#config = read_config(config_file)
frame_time_data = []
values = {}
dir_name = os.path.dirname(file) + "/"
file_name = file.replace(dir_name, "")
summary_file_name = file_name.replace(".mp4", "-summary.txt")
data_file_name = file_name.replace(".mp4", ".txt")
screen_cap_file_name = file_name.replace(".mp4", ".jpg")
object_file_name = file_name.replace(".mp4", "-objects.jpg")
time_file_name = file_name.replace(".mp4", "-time.txt")
capture_date = parse_file_date(file_name)
#last_cal_date = # Get last / closest calibration date
file_base_name = file_name.replace(".mp4", "")
print(capture_date)
status = day_or_night(config, capture_date)
if status == "day":
print("Skip this daytime file.")
move_file(dir_name + file_name, "day")
return ()
# read in time file if it exists
#if os.path.isfile(dir_name + "/" + time_file_name):
# frame_time_data = read_time_file(dir_name + "/" + time_file_name)
# print ("FRAME TIME DATA LENGTH:", len(frame_time_data))
# time.sleep(1)
#else:
# print ("no frame time data! " + dir_name + "/" + time_file_name )
# for x in range(0, 225):
# frame_time_data.append("|||")
#fps_t = 0
#for ftd in frame_time_data:
# print ("FRAMEdata", ftd)
# fps, tc, tt, tx = ftd.split("|")
# if fps == "":
# fps = 0
# fps_t = int(float(fps_t)) + int(float(fps))
#if len(frame_time_data) > 0:
# avg_fps = fps_t / len(frame_time_data)
#else :
# avg_fps = 0
avg_fps = 25
print("Viewing file: " + file)
print("Directory: " + dir_name)
print("File Name: " + file_name)
print("Summary File Name: " + summary_file_name)
print("Data File Name: " + data_file_name)
print("Screen Cap File Name: " + screen_cap_file_name)
print("Object File Name: " + object_file_name)
print("Capture Date: " + capture_date)
#print ("FPS: " + str(avg_fps))
# make sure the file exists
if os.path.isfile(file) is False:
print("This file does not exist. Exiting.")
return (0)
else:
print("The file is ok.")
#process video
tstamp_prev = None
image_acc = None
last_frame = None
last_gray_frame = None
nt_acc = None
nice_image_acc = None
final_image = None
cur_image = None
frame_count = 0
# open data log file
#fp = open(dir_name + "/" + data_file_name, "w")
#fp2 = open(dir_name + "/" + summary_file_name, "w")
#fp.write("frame|contours|x|y|w|h|color|fps|adjusted_unixtime|unixtime|time_offset\n")
#fp2.write("frame|contours|x|y|w|h|color|fps|adjusted_unixtime|unixtime|time_offset\n")
show = 1
if show == 1:
cv2.namedWindow('pepe')
#cap = skvideo.io.VideoCapture(file)
cap = cv2.VideoCapture(file)
time.sleep(2)
xs = []
ys = []
motion_frames = []
frames = []
colors = []
show_sw = 0
noise = 0
prev_motion = 0
cons_motion = 0
motion_events = []
while True:
_, frame = cap.read()
if frame is not None:
frame[680:720, 0:620] = [0, 0, 0]
frame_count = frame_count + 1
#frames.extend([frame])
if frame is None or nostars > 5:
if frame_count <= 1:
print("Bad file.")
return (0)
else:
end_time = int(time.time())
elapsed = end_time - start_time
print("Processed ", frame_count, "frames. in ", elapsed,
"seconds")
# finish processing file and write output files
total_motion = len(motion_frames)
if total_motion > 3:
half_motion = int(round(total_motion / 2, 0))
print("key frame #1 : ", 1)
print("key frame #2 : ", half_motion)
print("key frame #3 : ", total_motion - 1)
print("Xs", xs)
print("Ys", ys)
print("MF", motion_frames)
avg_color = sum(colors) / float(len(colors))
print("CL", colors)
print("Avg Color: ", avg_color)
#object_file_image = (frames[motion_frames[1]] * .33) + (frames[motion_frames[half_motion]] * .33) + (frames[motion_frames[total_motion-2]] * .33)
x1 = xs[1]
y1 = xs[1]
x2 = xs[half_motion]
y2 = xs[half_motion]
x3 = xs[total_motion - 2]
y3 = xs[total_motion - 2]
xmax = max(xs)
ymax = max(ys)
xmin = min(xs)
ymin = min(ys)
skip = 0
if xmax - xmin == 0 and ymax - ymin == 0:
skip = 1
straight_line = compute_straight_line(
x1, y1, x2, y2, x3, y3)
if len(motion_events) > 3:
max_cons_motion = max(motion_events)
if (straight_line < 1
and straight_line >= 0) or avg_color > 190:
meteor_yn = "Y"
else:
meteor_yn = "N"
if status == 'night':
meteor_yn = "Y"
else:
meteor_yn = "N"
if total_motion <= 3:
meteor_yn = "N"
#meteor_yn = "Y"
if skip == 1:
meteor_yn = "N"
print("Skipping not enough x,y movement!", xmax, xmin,
ymax, ymin)
if noise >= 5:
meteor_yn = "N"
print("Skipping to much noise!", noise)
if avg_fps < 20:
meteor_yn = "N"
print("Skipping calibration file!", avg_fps)
# write out the stacked image_acc and the stacked star file
# nt_acc
print("Writing:", acc_file)
print("Writing:", star_file)
#image_acc_cl = cv2.cvtColor(image_acc, cv2.COLOR_GRAY2BGR)
#en_image_acc = Image.fromarray(cv2.convertScaleAbs(image_acc))
enhancer = ImageEnhance.Brightness(final_image)
enhanced_image = enhancer.enhance(1)
np_enhanced_image = np.asarray(enhanced_image)
#cv2.imwrite(acc_file, np_enhanced_image)
print("Total Stars: ", total_stars)
if total_stars == 0:
star_file = star_file.replace("/stars/", "/clouds/")
acc_file = acc_file.replace("/stars/", "/clouds/")
cv2.imwrite(acc_file, np_enhanced_image)
if total_stars > 0:
cv2.imwrite(star_file, star_image)
#cv2.imshow('pepe', star_image)
#cv2.waitKey(100)
print("Status:", status)
print("Total Motion:", total_motion)
print("Cons Motion:", cons_motion)
print("Straight Line:", straight_line)
print("Likely Meteor:", meteor_yn)
#obj_outfile = dir_name + "/" + object_file_name
#sc_outfile = dir_name + "/" + screen_cap_file_name
#cv2.imwrite(obj_outfile, object_file_image)
#cv2.imwrite(sc_outfile, object_file_image)
#write summary & data files
#fp.close()
#fp2.close()
# prep event or capture for upload to AMS
values['datetime'] = capture_date
values['motion_frames'] = total_motion
values['cons_motion'] = max_cons_motion
values['color'] = avg_color
values['straight_line'] = straight_line
values['meteor_yn'] = meteor_yn
values['bp_frames'] = total_motion
print("ending here...")
exit()
if meteor_yn == 'Y':
try:
values['best_caldate'] = config['best_caldate']
except:
config['best_caldate'] = '0000-00-00 00:00:00'
values['best_caldate'] = config['best_caldate']
#try:
#log_fireball_event(config, file, dir_name + "/" + summary_file_name, dir_name + "/" + object_file_name, values)
#except:
# print ("failed to upload event file.")
# return(0)
#move files to maybe dir
print("Move to maybe dir!")
#os.system("mv " + dir_name + "/" + file_base_name + "* " + "/var/www/html/out/maybe/")
move_file(dir_name + file_name, "maybe")
else:
#log_motion_capture(config, dir_name + "/" + object_file_name, values)
#try:
#log_motion_capture(config, dir_name + "/" + object_file_name, values)
#except:
# print ("failed to upload capture file.")
# return(0)
#print ("Move to false dir!")
if (skip == 1 or noise >= 5) and status == 'night':
#os.system("mv " + dir_name + "/" + file_base_name + "* " + "/var/www/html/out/dist/")
move_file(dir_name + file_name, "dist")
elif avg_fps < 20:
move_file(dir_name + file_name, "calvid")
else:
if total_motion >= 3:
move_file(dir_name + file_name, "false")
else:
move_file(dir_name + file_name, "no_motion_night")
return (1)
# main video processing loop here
if status == "day":
mod_skip = 5
else:
mod_skip = 5
if frame_count % mod_skip == 0:
nice_frame = frame
alpha, tstamp_prev = iproc.getAlpha(tstamp_prev)
frame = cv2.resize(frame, (0, 0), fx=0.5, fy=0.5)
#print ("AFTER:", np.shape(frame))
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray_frame = frame
# if last_gray_frame is None:
# last_gray_frame = gray_frame
# else:
# gray_frame_cmb = gray_frame + last_gray_frame
# last_gray_frame = gray_frame
# gray_frame = gray_frame_cmb
frame = cv2.GaussianBlur(frame, (21, 21), 0)
if last_frame is None:
last_frame = nice_frame
if image_acc is None:
image_acc = np.empty(np.shape(frame))
image_diff = cv2.absdiff(
image_acc.astype(frame.dtype),
frame,
)
alpha = .076
hello = cv2.accumulateWeighted(frame, image_acc, alpha)
_, threshold = cv2.threshold(image_diff, 30, 255,
cv2.THRESH_BINARY)
thresh = cv2.dilate(threshold, None, iterations=2)
(_, cnts, xx) = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
frame_img = Image.fromarray(frame)
if final_image is None:
final_image = frame_img
final_image = ImageChops.lighter(final_image, frame_img)
if frame_count > 5:
np_final_image = np.asarray(final_image)
gray_nice_frame = cv2.cvtColor(nice_frame, cv2.COLOR_BGR2GRAY)
total_stars, star_image = find_stars(gray_nice_frame)
if total_stars == 0:
print("Cloudy...???")
nostars = nostars + 1
else:
nostars = 0
# if you want to stack the accumulated frames..
#image_acc_pil = Image.fromarray(cv2.convertScaleAbs(image_acc))
#final_image=ImageChops.lighter(final_image,image_acc_pil)
data = str(frame_count) + "|"
color = 0
contours = len(cnts)
x, y, w, h = 0, 0, 0, 0
if contours > 3:
noise = noise + 1
if contours > 0 and frame_count > 5:
x, y, w, h = cv2.boundingRect(cnts[0])
mx = x + w
my = y + h
cx = int(x + (w / 2))
cy = int(y + (h / 2))
color = gray_frame[cy, cx]
xs.extend([x])
ys.extend([y])
colors.extend([color])
motion_frames.extend([frame_count])
prev_motion = 1
cons_motion = cons_motion + 1
else:
if cons_motion > 0:
motion_events.append(cons_motion)
prev_motion = 0
line_data = ""
#line_data = str(frame_count) + "|" + str(contours) + "|" + str(x) + "|" + str(y) + "|" + str(w) + "|" + str(h) + "|" + str(color) + "|" + frame_time_data[frame_count-1] + "\n"
#fp.write(line_data)
#fp2.write(line_data)
print(frame_count, contours, x, y, w, h, color)
if frame_count % 10 == 0:
np_final_image = np.asarray(final_image)
np_star_image = np.asarray(star_image)
small_star_image = cv2.resize(star_image, (0, 0),
fx=0.5,
fy=0.5)
#cv2.imshow('pepe', small_star_image)
cv2.imshow('pepe', np_final_image)
#cv2.imshow('pepe', cv2.convertScaleAbs(image_acc))
cv2.waitKey(1)
def az_grid_borders(file):
cam_num = 1
config_file = "conf/config-" + str(cam_num) + ".txt"
config = read_config(config_file)
loc_lat = config['device_lat']
loc_lon = config['device_lng']
loc_alt = config['device_alt']
W = WCS(file)
image_file = file.replace("-sd.new", ".jpg")
cal_time = parse_file_date(image_file)
location = EarthLocation.from_geodetic(float(loc_lon)*u.deg,float(loc_lat)*u.deg,float(loc_alt)*u.m)
az_grid = cv2.imread(image_file)
az_grid_np = cv2.cvtColor(az_grid, cv2.COLOR_BGR2GRAY)
mypass = 0
print ("Grid y is ", az_grid_np.shape[0])
print ("Grid x is ", az_grid_np.shape[1])
last_az_pp = 0
last_at_pp = 0
avg_az_pp = 0
avg_at_pp = 0
az_pp = 0
at_pp = 0
last_alt= 0
last_az = 0
last_x = None
last_y = None
# solve left
x = 0
for y in range(az_grid_np.shape[0]):
(oalt,oaz) = convert_xy_to_altaz(x,y,W,location,cal_time)
remat = 10 - (oalt % 10)
remaz = 10 - (oaz % 10)
if remat > 9.3:
print ("LEFT-ALT", x,y,oaz,oalt)
if remaz > 9.3:
print ("LEFT-AZ", x,y,oaz,oalt)
# solve right
x = az_grid_np.shape[1]
for y in range(az_grid_np.shape[0]):
(oalt,oaz) = convert_xy_to_altaz(x,y,W,location,cal_time)
remat = 10 - (oalt % 10)
remaz = 10 - (oaz % 10)
if remat > 9.3:
print ("RIGHT-ALT", x,y,oaz,oalt)
if remaz > 9.3:
print ("RIGHT-AZ", x,y,oaz,oalt)
# solve top
y = 0
for x in range(az_grid_np.shape[1]):
(oalt,oaz) = convert_xy_to_altaz(x,y,W,location,cal_time)
remat = 10 - (oalt % 10)
remaz = 10 - (oaz % 10)
if remat > 9.3:
print ("TOP-ALT", x,y,oaz,oalt)
if remaz > 9.3:
print ("TOP-AZ", x,y,oaz,oalt)
# solve bottom
y = az_grid.shape[0]
for x in range(az_grid_np.shape[1]):
(oalt,oaz) = convert_xy_to_altaz(x,y,W,location,cal_time)
remat = 10 - (oalt % 10)
remaz = 10 - (oaz % 10)
if remat > 9.3:
print ("BOTTOM-ALT", x,y,oaz,oalt)
if remaz > 9.3:
print ("BOTTOM-AZ", x,y,oaz,oalt)
# solve middle
x = int(az_grid.shape[0] * .5)
for y in range(az_grid_np.shape[1]):
(oalt,oaz) = convert_xy_to_altaz(x,y,W,location,cal_time)
remat = 10 - (oalt % 10)
remaz = 10 - (oaz % 10)
if remat > 9.3:
print ("MID-ALT", x,y,oaz,oalt)
if remaz > 9.3:
print ("MID-AZ", x,y,oaz,oalt)
# solve middle left
x = int(az_grid.shape[0] * .33333)
for y in range(az_grid_np.shape[1]):
(oalt,oaz) = convert_xy_to_altaz(x,y,W,location,cal_time)
remat = 10 - (oalt % 10)
remaz = 10 - (oaz % 10)
if remat > 9.3:
print ("MIDL-ALT", x,y,oaz,oalt)
if remaz > 9.3:
print ("MIDL-AZ", x,y,oaz,oalt)
# solve middle right
x = int(az_grid.shape[0] * .66666667)
for y in range(az_grid_np.shape[1]):
(oalt,oaz) = convert_xy_to_altaz(x,y,W,location,cal_time)
remat = 10 - (oalt % 10)
remaz = 10 - (oaz % 10)
if remat > 9.3:
print ("MIDR-ALT", x,y,oaz,oalt)
if remaz > 9.3:
print ("MIDR-AZ", x,y,oaz,oalt)
#!/usr/bin/python3
import requests
import sys
from amscommon import read_config
cam_num = sys.argv[1]
config = read_config("conf/config-" + cam_num + ".txt")
r = requests.get(
"http://" + config['cam_ip'] +
"/webs/btnSettingEx?flag=1000¶mchannel=0¶mcmd=1058¶mctrl=25¶mstep=0¶mreserved=0&"
)
def draw_az_grid(file):
first_list = []
cam_num = 1
config_file = "conf/config-" + str(cam_num) + ".txt"
config = read_config(config_file)
loc_lat = config['device_lat']
loc_lon = config['device_lng']
loc_alt = config['device_alt']
W = WCS(file)
image_file = file.replace("-sd.new", ".jpg")
cal_time = parse_file_date(image_file)
location = EarthLocation.from_geodetic(float(loc_lon)*u.deg,float(loc_lat)*u.deg,float(loc_alt)*u.m)
az_grid = cv2.imread(image_file)
az_grid_np = cv2.cvtColor(az_grid, cv2.COLOR_BGR2GRAY)
#azpp1, altpp1 = characterize_altaz(0,0,320,180,W, location, cal_time)
#azpp2, altpp2 = characterize_altaz(0,0,0,360,W, location, cal_time)
#azpp3, altpp3 = characterize_altaz(0,0,640,0,W, location, cal_time)
mypass = 0
print ("Grid y is ", az_grid_np.shape[0])
print ("Grid x is ", az_grid_np.shape[1])
last_az_pp = 0
last_at_pp = 0
avg_az_pp = 0
avg_at_pp = 0
az_pp = 0
at_pp = 0
last_alt= 0
last_az = 0
last_x = None
last_y = None
for x in range(0,az_grid_np.shape[1]):
if (x % 50 == 0) :
for y in range(az_grid_np.shape[0]):
if mypass >= 1:
mypass = mypass - 1
#print ("pass is ", mypass, "skipping")
continue
else:
if (y % 1 == 0) :
#print("TRACE: ", x,y,cal_time)
(oalt,oaz) = convert_xy_to_altaz(x,y,W,location,cal_time)
remat = 10 - (oalt % 10)
remaz = 10 - (oaz % 10)
#print ("REMAT/REMAZ: ", remat, remaz)
if remat < .7 or remat > 9.3:
print ("**** x,y,az,alt", remat, x,y,oaz,oalt)
az_grid[y,x] = [255,255,255]
mypass = 20
else:
# print ("remat, x,y,az,alt", remat,x,y,oaz,oalt)
if avg_at_pp != 0:
skip = remat / avg_at_pp
#print ("skip = ", skip)
mypass = skip * .5
if remat > 7:
mypass = 0
if last_x != None:
if abs(x - last_x) != 0:
az_pp = abs(oaz - last_az) / abs(x - last_x)
else:
az_pp = 0
if abs(y - last_y) != 0:
at_pp = abs(oalt - last_alt) / abs(y - last_y)
else:
at_pp = 0
#print ("AZ/EL Per Pixel = ", last_az_pp, last_at_pp)
if avg_az_pp == 0:
avg_az_pp = az_pp
avg_az_pp = (avg_az_pp + last_az_pp + az_pp) / 3
if avg_at_pp == 0:
avg_at_pp = at_pp
avg_at_pp = (avg_at_pp + last_at_pp + at_pp) / 3
last_az_pp = az_pp
last_at_pp = at_pp
last_az = oaz
last_alt = oalt
last_x = x
last_y = y
for y in range(0,az_grid_np.shape[0]):
if (y % 50 == 0) :
for x in range(az_grid_np.shape[1]):
if mypass >= 1:
mypass = mypass - 1
#print ("pass is ", mypass, "skipping")
continue
else:
if (x % 1 == 0) :
(oalt,oaz) = convert_xy_to_altaz(x,y,W,location,cal_time)
remat = 10 - (oalt % 10)
remaz = 10 - (oaz % 10)
#print ("REMAT/REMAZ: ", remat, remaz)
if remaz < .7 or remaz > 9.3:
print ("**** x,y,az,alt", x,y,oaz,oalt)
az_grid[y,x] = [255,255,255]
mypass = 20
else:
#print ("remaz, x,y,az,alt", remaz,x,y,oaz,oalt)
if remaz > 8:
mypass = 20
if remaz < 8 and remaz > 5:
mypass = 8
if remaz < 5 and remaz > 3:
mypass = 4
if remaz < 3:
mypass = 0
cv2.imwrite("azgrid.png", az_grid)
from view import log_fireball_event
from amscommon import read_config, caldate
values = {}
values['datetime'] = "2017-06-22 13:27:58"
values['motion_frames'] = 2
values['cons_motion'] = 2
values['color'] = 1
values['straight_line'] = 1
values['meteor_yn'] = 0
values['bp_frames'] = 3
log_fireball_event(read_config(), "./test_data/20170622132758.avi",
"./test_data/20170622132758-summary.txt",
"./test_data/20170622132758-objects.jpg", values)
def read_noise(config_file, cam_num):
#cv2.namedWindow('pepe')
last_frame = None
config = read_config(config_file)
cur_settings = get_settings(config)
new_brightness = int(cur_settings['Brightness'])
cap = cv2.VideoCapture("rtsp://" + config['cam_ip'] + "/av0_1")
print(config['cam_ip'])
fcnn = 0
nr = 0
nrfc = 0
nrc = 0
cc = 0
for fc in range(0, 1000):
_, frame = cap.read()
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frame_time = time.time()
format_time = datetime.datetime.fromtimestamp(
int(frame_time)).strftime("%Y%m%d%H%M%S")
if frame is not None:
#frame[680:720, 0:620] = [255]
#frame[340:360, 0:310] = [255]
frame[460:480, 0:310] = [255]
if last_frame is not None and fc > 10:
image_diff = cv2.absdiff(
last_frame,
frame,
)
_, threshold = cv2.threshold(image_diff, 30, 255,
cv2.THRESH_BINARY)
noise = threshold.sum()
if (noise > 0):
nrc = nrc + 1
if cc == 150:
nr = nrc / nrfc
print("Noise ratio is: ", nrc, nrfc, nr)
nrc = 0
nrfc = 0
cc = 0
if .02 <= nr < .05:
print("brightness is good.", new_brightness)
return ()
if nr >= .05:
print("Too much noise, lower brightness")
if nr > .4:
new_brightness = new_brightness - 10
else:
new_brightness = new_brightness - 2
set_setting(config, "Brightness", new_brightness)
print("New Brightness", new_brightness)
if new_brightness < 60:
exit()
else:
print("not enough noise, increase brightness")
new_brightness = new_brightness + 5
set_setting(config, "Brightness", new_brightness)
print("New Brightness", new_brightness)
time.sleep(1)
#cv2.imshow('pepe', threshold)
#cv2.imshow('pepe', frame)
#cv2.waitKey(1)
cc = cc + 1
last_frame = frame
nrfc = nrfc + 1
#!/usr/bin/python3
import os
import time
from amscommon import read_config
import netifaces
# system boot script runs each time system is booted.
# Handles first time registration and setup
# once setup simply does sanity check and logs to ams
time.sleep(30)
config = read_config()
try:
if (config['device_lat'] != ''):
print("setup.")
except:
print("device not setup yet.")
fp = open("/home/pi/fireball_camera/booted.txt", "w")
fp.write("booted")
fp.close()
os.system(
"cd /home/pi/fireball_camera; ./mkdevice.py > /home/pi/fireball_camera/boot-log.txt"
)
try:
eth0_ip = netifaces.ifaddresses('eth0')[netifaces.AF_INET][0]['addr']
except:
eth0_ip = "0.0.0.0"
try:
wlan0_ip = netifaces.ifaddresses('wlan0')[netifaces.AF_INET][0]['addr']
def get_calibration_frames(config_file, cam_num):
config = read_config(config_file)
prev_settings = get_settings(config)
#print (prev_settings)
#exit();
settings = custom_settings("Calibration", config)
fp = open("/home/pi/fireball_camera/calnow" + str(cam_num), "w")
# set brightness
set_setting(config, "Brightness", settings['Brightness'])
#print ("setting brightness to ", settings['Brightness'])
# set BLC
set_special(config, "1017", settings['BLC'])
#print ("setting BLC to ", settings['BLC'])
# set Gamma
set_setting(config, "Gamma", settings['Gamma'])
#print ("setting Gamma to ", settings['Gamma'])
# set contrast
set_setting(config, "Contrast", settings['Contrast'])
time.sleep(2)
#print ("setting Contrast to ", settings['Contrast'])
# sense up
r = requests.get(
"http://" + config['cam_ip'] +
"/webs/btnSettingEx?flag=1000¶mchannel=0¶mcmd=1058¶mctrl=12¶mstep=0¶mreserved=0&"
)
time.sleep(3)
os.system("./allsky6-calibrate.py read_noise " + str(cam_num))
cap = cv2.VideoCapture("rtsp://" + config['cam_ip'] + "/av0_0")
#read_noise(config_file, cam_num)
cv2.setUseOptimized(True)
#lock = open("/home/pi/fireball_camera/calibrate.txt", "w")
time_start = time.time()
time.sleep(15)
med_arr = []
final_image = None
for i in range(0, 100, 1):
_, frame = cap.read()
#frame = cv2.resize(frame, (0,0), fx=1, fy=.75)
if i % 15 != 0 or i == 0:
if frame is not None:
med_arr.append(frame)
print("Getting frame.")
else:
print("LEN MED", len(med_arr))
med_arr_np = np.array(med_arr)
median_image = np.median(med_arr_np, axis=0)
median = np.uint8(median_image)
frame_img = Image.fromarray(median)
if final_image is None:
final_image = frame_img
final_image = ImageChops.lighter(final_image, frame_img)
#out_file = "/var/www/html/out/temp_upload/stack.jpg"
frame_time = time.time()
format_time = datetime.datetime.fromtimestamp(
int(frame_time)).strftime("%Y%m%d%H%M%S")
out_file = "{}/{}-{}.jpg".format("/mnt/ams2/cal", format_time, cam_num)
final_image.save(out_file, "JPEG")
time.sleep(10)
# sense camera down
r = requests.get(
"http://" + config['cam_ip'] +
"/webs/btnSettingEx?flag=1000¶mchannel=0¶mcmd=1058¶mctrl=50¶mstep=0¶mreserved=0&"
)
cap.release()
# set BLC
#set_special(config, "1017", "30")
# set brightness contrast gamma and BLC back to original setting before calibration
#set_setting(config, "Contrast", prev_settings['Contrast'])
#print ("setting brightness back to ", prev_settings['Brightness'])
#set_setting(config, "Brightness", prev_settings['Brightness'])
#set_setting(config, "Gamma", prev_settings['Gamma'])
time.sleep(3)
os.system("rm /home/pi/fireball_camera/calnow" + str(cam_num))
os.system("/home/pi/fireball_camera/sro-settings.py " + str(cam_num))
config['cam_ip']
) + "/webs/btnSettingEx?flag=1000¶mchannel=0¶mcmd=" + str(
field) + "¶mctrl=" + str(value) + "¶mstep=0¶mreserved=0"
print(url)
r = requests.get(url)
print(r.text)
if sys.argv[1] == 'ip':
config['cam_ip'] = sys.argv[2]
cam_num = sys.argv[3]
else:
try:
cam_num = sys.argv[1]
config_file = "conf/config-" + cam_num + ".txt"
config = read_config(config_file)
except:
config = read_config(config_file)
cam_ip = config['cam_ip']
print(config['cam_ip'])
config['cam_pwd'] = "xrp23q"
#config = read_config()
#try:
# cam_ip = sys.argv[1]
#except:
# cam_ip = config['cam_ip']
#device_id = config['device_id']
def diff_stills(sdate, cam_num, show_video):
if show_video == 1:
cv2.namedWindow('pepe')
image_thresh = []
med_last_objects = []
last_objects = deque(maxlen=5)
diffed_files = []
config = read_config("conf/config-1.txt")
video_dir = "/mnt/ams2/SD/"
images = []
images_orig = []
images_blend = []
images_info = []
count = 0
last_image = None
last_thresh_sum = 0
hits = 0
avg_cnt = 0
avg_tot = 0
avg_pts = 0
count = 0
glob_dir = video_dir + "proc/" + sdate + "/" + "*cam" + str(cam_num) + "-blend.jpg"
report_file = video_dir + "proc/" + sdate + "/" + sdate + "-cam" + str(cam_num) + "-report.txt"
master_stack_file = video_dir + "proc/" + sdate + "/" + sdate + "-cam" + str(cam_num) + "-master_stack.jpg"
#cv2.namedWindow('pepe')
mask_file = "conf/mask-" + str(cam_num) + ".txt"
file_exists = Path(mask_file)
mask_exists = 0
still_mask = [0,0,0,0]
if (file_exists.is_file()):
print("File found.")
ms = open(mask_file)
for lines in ms:
line, jk = lines.split("\n")
exec(line)
ms.close()
mask_exists = 1
(sm_min_x, sm_max_x, sm_min_y, sm_max_y) = still_mask
diffs = 0
image_list = []
file_list = []
sorted_list = []
print ("Loading still images from ", glob_dir)
for filename in (glob.glob(glob_dir)):
capture_date = parse_file_date(filename)
sun_status, sun_alt = day_or_night(config, capture_date)
#if sun_status != 'day' and int(sun_alt) < -4:
#print("NIGHTTIME", capture_date, filename, sun_status)
file_list.append(filename)
#else:
# print ("This is a daytime or dusk file", filename)
sorted_list = sorted(file_list)
print ("Loading Images...")
for filename in sorted_list:
open_cv_image = cv2.imread(filename,0)
orig_image = open_cv_image
open_cv_image[440:480, 0:640] = [0]
images_orig.append(orig_image)
images.append(open_cv_image)
print ("Finished Loading Images.", len(sorted_list))
if len(sorted_list) == 0:
print ("Pre-processing of stack blends has not happened yet. Aborting...")
exit()
diff_sums = []
height , width = open_cv_image.shape
master_stack = None
objects = None
last_line_groups = []
last_points = []
count = 0
cnts_counts = []
for filename in sorted_list:
thresh_file = filename.replace("blend", "diff")
file_exists = Path(thresh_file)
if (file_exists.is_file()):
open_cv_image = cv2.imread(thresh_file,0)
image_thresh.append(open_cv_image)
sum = np.sum(open_cv_image)
diff_sums.append(sum)
# file already exists, just load it and move forward
else:
# file doesn't exist yet so make it and save it.
print ("THESH: ", thresh_file)
hit = 0
detect = 0
el = filename.split("/")
fn = el[-1]
current_image = images[count]
current_filename = sorted_list[count]
if count >= 2:
before_image2 = images[count-2]
before_image = images[count-1]
before_filename = sorted_list[count-1]
else:
before_image2 = images[count+2]
before_image = images[count+2]
before_filename = sorted_list[count+2]
if count >= len(sorted_list)-2:
after_image2 = images[count-3]
after_image = images[count-2]
after_filename = sorted_list[count-2]
else:
after_image2 = images[count+2]
after_image = images[count+1]
after_filename = sorted_list[count+1]
if count < 25:
median = np.median(np.array(images[0:count+25]), axis=0)
elif len(images) - count < 25:
median = np.median(np.array(images[count-25:count]), axis=0)
else:
median = np.median(np.array(images[count-25:count]), axis=0)
median = np.uint8(median)
blur_med = cv2.GaussianBlur(median, (5, 5), 0)
# find bright areas in median and mask them out of the current image
tm = find_best_thresh(blur_med, 30, 1)
md = np.median(blur_med)
av = np.average(blur_med)
#tm = md + (av /1)
#median_thresh = cv2.adaptiveThreshold(blur_med,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY,11,1)
_, median_thresh = cv2.threshold(blur_med, tm, 255, cv2.THRESH_BINARY)
(_, median_cnts, xx) = cv2.findContours(median_thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
med_diff = cv2.absdiff(current_image.astype(current_image.dtype), median,)
image_diff = cv2.absdiff(current_image.astype(current_image.dtype), before_image,)
image_diff2 = cv2.absdiff(current_image.astype(current_image.dtype), before_image2,)
aft_image_diff = cv2.absdiff(current_image.astype(current_image.dtype), after_image,)
aft_image_diff2 = cv2.absdiff(current_image.astype(current_image.dtype), after_image2,)
bef_aft_image_diff = cv2.absdiff(before_image.astype(current_image.dtype), after_image,)
median_three = np.median((image_diff, image_diff2, aft_image_diff, aft_image_diff2, med_diff, current_image), axis=0)
median_three = np.uint8(median_three)
# block out bright parts of the median
for (i,c) in enumerate(median_cnts):
x,y,w,h = cv2.boundingRect(median_cnts[i])
my = y - 30
mx = x - 30
mmy = y + 30
mmx = x + 30
if mmy >= current_image.shape[0]:
mmy =current_image.shape[0]
if mmx >= current_image.shape[1]:
mmx =current_image.shape[1]
image_diff[my:mmy, mx:mmx] = [0]
#before_image[my:mmy, mx:mmx] = [0]
md = np.median(current_image)
av = np.average(current_image)
print ("working on (md,av): ", filename, md, av)
#thresh_limit = md + (av /1)
thresh_limit = 10
#_, thresh = cv2.threshold(median_three, thresh_limit, 255, cv2.THRESH_BINARY)
thresh = cv2.adaptiveThreshold(median_three,255,cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY,11,-10)
this_thresh = thresh.copy()
cnts = []
real_cnt = 0
real_cnt_space = 0
if count >= 1:
# zero out the bright areas in the last image diff so they don't show up in this one.
(_, cnts, xx) = cv2.findContours(last_thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
for (i,c) in enumerate(cnts):
x,y,w,h = cv2.boundingRect(cnts[i])
this_thresh[y-20:y+h+20, x-20:x+w+20] = [0]
# before_image[y-20:y+h+20, x-20:x+w+20] = [0]
if w > 1 and h > 1:
real_cnt = real_cnt + 1
real_cnt_space = real_cnt_space + (w*h)
last_thresh = thresh
sum = np.sum(this_thresh)
diff_sums.append(sum)
#noise, this_thresh = find_noisy_cnts(this_thresh)
#if count > 0:
#cv2.putText(this_thresh, str(before_filename), (5,460), cv2.FONT_HERSHEY_SIMPLEX, .4, (255), 1)
#cv2.putText(this_thresh, str(current_filename), (5,470), cv2.FONT_HERSHEY_SIMPLEX, .4, (255), 1)
if show_video == 1:
cv2.imshow('pepe', cv2.convertScaleAbs(median_three))
cv2.waitKey(100)
cv2.imshow('pepe', this_thresh)
cv2.waitKey(100)
cv2.imwrite(thresh_file, this_thresh)
image_thresh.append(this_thresh)
#if (len(image_thresh) > 1000):
# break
cnts_counts.append((real_cnt,real_cnt_space))
count = count + 1
exit()
md = np.median(diff_sums)
mav = np.average(diff_sums)
count = 0
dfs_count = 0
noise = 0
for img in image_thresh:
current_image = images[count]
file = sorted_list[count]
sum = diff_sums[count]
#cnt_count,cnt_space = cnts_counts[count]
print(file)
#noise, img = find_noisy_cnts(img)
good, good_angles, img = find_cnts(img)
print ("CNTs,S,Noise,M,A,G,GA:", good, noise, sum, md, mav, good, good_angles)
#edges = cv2.Canny(img, 30,255)
blend = cv2.addWeighted(img, .2, current_image, .8,0)
#cv2.imshow('pepe', img)
#if good >= 0 and good_angles >= 0:
# dfs_count = dfs_count + 1
# while(1):
# k = cv2.waitKey(33)
# if k == 32:
# break
# if k == 27:
# exit()
#else:
# cv2.waitKey(1)
count = count + 1
print ("Total Images:", count)
print ("Total Diffs:", dfs_count)
