frame_extraction.hpp

Go to the documentation of this file.

/*
 * CPP_Birdtracker/frame_extraction.hpp - Primary header LunAero birdtracker.
 * Copyright (C) <2020>  <Wesley T. Honeycutt>
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef FRAME_EXTRACTION_H
#define FRAME_EXTRACTION_H

// Includes
#include <algorithm>
#include <ctime>                         // for NULL
#include <errno.h>
#include <tgmath.h>                      // for sin, cos, etc.
#include <fcntl.h>
#include <fstream>
#include <iostream>
#include <numeric>                       // for accumulate
#include <pthread.h>
#include <signal.h>
#include <stdlib.h>                      // for exit
#include <sys/ipc.h>                     // for IPC_CREAT, key_t
#include <sys/shm.h>                     // for shmat
#include <sys/mman.h>                    // for MAP_ANONYMOUS, MAP_SHARED
#include <sys/wait.h>
#include <tuple>
#include <unistd.h>                      // for fork, sleep, usleep
#include <typeinfo>
#include <regex>

#include <string>                        // for string
using std::string;

#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;

#include <vector>                        // for vector
using std::vector;

#include "opencv2/opencv.hpp"
#include "opencv2/ximgproc.hpp"
using namespace cv;

// std::map<std::string, std::string> options;

// Global Variables
int MAJOR_VERSION = 0;
int MINOR_VERSION = 3;
std::string ALPHA_BETA = "-alpha";
int SIG_ALERT = 0;
double ORIG_AREA;
double ORIG_PERI;
int ORIG_VERT;
int ORIG_HORZ;
int BOXSIZE;
Point ORIG_TL;
Point ORIG_BR;
std::string LOGOUT;
std::ofstream LOGGING;
std::string TIER1FILE;
std::string TIER2FILE;
std::string TIER3FILE;
std::string TIER4FILE;
std::string ELLIPSEDATA;
std::string BOXDATA;
std::string METADATA;
int TC_W;
int TC_H;
bool CAUGHT_EMPTY = false;




// Globals that Doxygen doesn't need to see
#ifndef DOXYGEN_SHOULD_SKIP_THIS
//
Mat HNC_FRAME;

//
Mat IC_FRAME;

//
Rect BF_BOX;

#endif




// Global Variables declared in settings.cfg
bool DEBUG_FRAMES = false;
bool DEBUG_COUT = false;
bool OUTPUT_FRAMES = false;
bool EMPTY_FRAMES = true;
bool GEN_SLIDESHOW = true;
bool SIMP_ELL = true;
bool CONCAT_TIERS = true;
bool TIGHT_CROP = true;
std::string OSFPROJECT = "";
std::string OUTPUTDIR = "Birdtracker_Output/";
int EDGETHRESH = 10;
int QHE_WIDTH = 10;
int BLACKOUT_THRESH = 51;

int CONVERT_FPS = 30;
int NON_ZERO_START = 0;


int QHE_GB_KERNEL_X = 15;
int QHE_GB_KERNEL_Y = 15;
double QHE_GB_SIGMA_X = 1;
double QHE_GB_SIGMA_Y = 1;



double T1_AT_MAX = 255;
int T1_AT_BLOCKSIZE = 65;
double T1_AT_CONSTANT = 35;
int T1_DYMASK = 25;


double T2_AT_MAX = 255;
int T2_AT_BLOCKSIZE = 65;
double T2_AT_CONSTANT = 20;
int T2_DYMASK = 25;


int T3_LAP_KERNEL = 11;
double T3_LAP_SCALE = 0.0001;
double T3_LAP_DELTA = 0;
int T3_GB_KERNEL_X = 11;
int T3_GB_KERNEL_Y = 11;
double T3_GB_SIGMA_X = 1;
double T3_GB_SIGMA_Y = 1;
int T3_CUTOFF_THRESH = 40;
int T3_DYMASK = 45;


double T4_AT_MAX = 255;
int T4_AT_BLOCKSIZE = 65;
double T4_AT_CONSTANT = 20;
double T4_POWER = 2;
int T4_GB_KERNEL_X = 11;
int T4_GB_KERNEL_Y = 11;
double T4_GB_SIGMA_X = 1;
double T4_GB_SIGMA_Y = 1;
int T4_THINNING = 0;
int T4_DYMASK = 45;


// Declared functions/prototypes
static Mat shift_frame(Mat in_frame, int shiftx, int shifty);
static Mat corner_matching(Mat in_frame, vector<Point> contour, int plusx, int plusy);
static vector <int> test_edges(Mat in_frame, vector<Point> contour, int te_ret);
static int min_square_dim(Mat in_frame);
static vector <int> edge_width(vector<Point> contour);
static vector <int> edge_height(vector<Point> contour);
static int initial_crop(Mat in_frame, int framecnt);
static int touching_edges(Mat in_frame, vector<Point> contour);
static Mat traditional_centering(Mat in_frame, vector <vector<Point>> contours, int largest, Rect box);
static int first_frame(Mat in_frame, int framecnt);
static int halo_noise_and_center(Mat in_frame, int framecnt);
static void signal_callback_handler(int signum);
static Mat apply_dynamic_mask(Mat in_frame, vector<vector<Point>> contours, int maskwidth);
static int largest_contour(vector <vector<Point>> contours);
static vector <vector<Point>> contours_only(Mat in_frame);
static int box_finder(Mat in_frame, bool do_thresh);
static int box_data(Rect box, int framecnt);
static int show_usage(string name);
static vector <Point> qhe_bigone(Mat in_frame);
static vector <vector<Point>> quiet_halo_elim(vector <vector<Point>> contours, vector <Point> bigone);
static int tier_one(int cnt, Mat in_frame, vector <Point> bigone);
static int tier_two(int cnt, Mat in_frame, vector <Point> bigone);
static int tier_three(int cnt, Mat in_frame, Mat old_frame, vector <Point> bigone);
static int tier_four(int cnt, Mat in_frame, Mat old_frame, vector <Point> bigone);
static int parse_checklist(std::string name, std::string value);
static std::string out_frame_gen(int framecnt);
std::string space_space(std::string instring);
static int generate_slideshow();
static int concat_tiers();
static int off_screen_ellipse();
static int post_processing();
int main(int argc, char* argv[]); 

#endif