304 lines
10 KiB
C++
304 lines
10 KiB
C++
/* -*- c++ -*- */
|
|
/*
|
|
* gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
|
|
*
|
|
* Copyright (C) 2017, Libre Space Foundation <http://librespacefoundation.org/>
|
|
*
|
|
* 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/>.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <gnuradio/io_signature.h>
|
|
#include "noaa_apt_sink_impl.h"
|
|
|
|
#include <cmath>
|
|
|
|
namespace gr
|
|
{
|
|
namespace satnogs
|
|
{
|
|
// Factor exponential smoothing average,
|
|
// which is used for sync pattern detection
|
|
const float noaa_apt_sink_impl::f_average_alpha = 0.25;
|
|
|
|
// The images are written to disk every d_row_write_threshold lines
|
|
// so in case something goes horribly wrong, partial images will be available
|
|
const size_t noaa_apt_sink_impl::d_row_write_threshold = 250;
|
|
|
|
// Noaa apt sync pattern A
|
|
// (see https://sourceforge.isae.fr/attachments/download/1813/apt_synch.gif)
|
|
const bool noaa_apt_sink_impl::synca_seq[] = {false, false, false, false,
|
|
true, true, false, false, // Pulse 1
|
|
true, true, false, false, // Pulse 2
|
|
true, true, false, false, // Pulse 3
|
|
true, true, false, false, // Pulse 4
|
|
true, true, false, false, // Pulse 5
|
|
true, true, false, false, // Pulse 6
|
|
true, true, false, false, // Pulse 7
|
|
false, false, false, false,
|
|
false, false, false, false};
|
|
|
|
// Noaa apt sync pattern B
|
|
// (see https://sourceforge.isae.fr/attachments/download/1813/apt_synch.gif)
|
|
const bool noaa_apt_sink_impl::syncb_seq[] = {false, false, false, false,
|
|
true, true, true, false, false,
|
|
true, true, true, false, false,
|
|
true, true, true, false, false,
|
|
true, true, true, false, false,
|
|
true, true, true, false, false,
|
|
true, true, true, false, false,
|
|
true, true, true, false, false,
|
|
false};
|
|
|
|
|
|
|
|
noaa_apt_sink::sptr
|
|
noaa_apt_sink::make (const char *filename_png, size_t width, size_t height,
|
|
bool split, bool sync, bool flip)
|
|
{
|
|
return gnuradio::get_initial_sptr (
|
|
new noaa_apt_sink_impl (filename_png, width, height, split, sync,
|
|
flip));
|
|
}
|
|
|
|
|
|
/*
|
|
* The private constructor
|
|
*/
|
|
noaa_apt_sink_impl::noaa_apt_sink_impl (const char *filename_png,
|
|
size_t width, size_t height,
|
|
bool split, bool sync, bool flip) :
|
|
gr::sync_block ("noaa_apt_sink",
|
|
gr::io_signature::make (1, 1, sizeof(float)),
|
|
gr::io_signature::make (0, 0, 0)),
|
|
d_filename_png (filename_png),
|
|
d_width (width),
|
|
d_height (height),
|
|
d_split (split),
|
|
d_synchronize_opt (sync),
|
|
d_flip (flip),
|
|
d_history_length (40),
|
|
d_has_sync (false),
|
|
d_current_x (0),
|
|
d_current_y (0),
|
|
d_num_images (0),
|
|
f_max_level(0.0),
|
|
f_min_level(1.0),
|
|
f_average(0.0)
|
|
{
|
|
set_history(d_history_length);
|
|
init_images();
|
|
}
|
|
|
|
|
|
void
|
|
noaa_apt_sink_impl::init_images () {
|
|
size_t len = d_filename_png.size();
|
|
size_t pos = d_filename_png.rfind('.');
|
|
std::string base_filename = d_filename_png.substr(0, pos);
|
|
std::string extension = d_filename_png.substr(pos+1, len-1);
|
|
|
|
d_full_filename = base_filename + std::to_string(d_num_images) + "." + extension;
|
|
d_full_image = png::image<png::gray_pixel>(d_width, d_height);
|
|
|
|
if(d_split) {
|
|
d_left_filename = base_filename + "_left" + std::to_string(d_num_images) + "." + extension;
|
|
d_right_filename = base_filename + "_right" + std::to_string(d_num_images)+ "." + extension;
|
|
|
|
d_left_image = png::image<png::gray_pixel>(d_width/2, d_height);
|
|
d_right_image = png::image<png::gray_pixel>(d_width/2, d_height);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
noaa_apt_sink_impl::write_image (png::image<png::gray_pixel> image, std::string filename) {
|
|
if(d_flip) {
|
|
size_t width = image.get_width();
|
|
size_t height = image.get_height();
|
|
|
|
png::image<png::gray_pixel> flipped(width, height);
|
|
|
|
for(size_t y = 0; y < height; y++) {
|
|
for(size_t x = 0; x < width; x++) {
|
|
auto pixel = image.get_pixel(x, height - y - 1);
|
|
flipped.set_pixel(x, y, pixel);
|
|
}
|
|
}
|
|
flipped.write(filename);
|
|
}
|
|
else {
|
|
image.write(filename);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
noaa_apt_sink_impl::write_images () {
|
|
write_image(d_full_image, d_full_filename);
|
|
|
|
if(d_split) {
|
|
write_image(d_left_image, d_left_filename);
|
|
write_image(d_right_image, d_right_filename);
|
|
}
|
|
}
|
|
|
|
|
|
noaa_apt_sink_impl::~noaa_apt_sink_impl () {
|
|
|
|
}
|
|
|
|
bool
|
|
noaa_apt_sink_impl::stop () {
|
|
auto buf_full_image = d_full_image.get_pixbuf();
|
|
auto buf_left_image = d_left_image.get_pixbuf();
|
|
auto buf_right_image = d_right_image.get_pixbuf();
|
|
|
|
d_full_image = png::image<png::gray_pixel>(d_width, d_current_y + 1);
|
|
d_full_image.set_pixbuf(buf_full_image);
|
|
|
|
d_left_image = png::image<png::gray_pixel>(d_width/2, d_current_y + 1);
|
|
d_left_image .set_pixbuf(buf_left_image);
|
|
|
|
d_right_image = png::image<png::gray_pixel>(d_width/2, d_current_y + 1);
|
|
d_right_image.set_pixbuf(buf_right_image);
|
|
|
|
write_images();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void noaa_apt_sink_impl::set_pixel (size_t x, size_t y, float sample) {
|
|
sample = (sample - f_min_level) / (f_max_level - f_min_level) * 255;
|
|
d_full_image.set_pixel(x, y, sample);
|
|
|
|
if(d_split) {
|
|
if(x < d_width / 2) {
|
|
d_left_image.set_pixel(x, y, sample);
|
|
}
|
|
else {
|
|
d_right_image.set_pixel(x - d_width / 2, y, sample);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
noaa_apt_sink_impl::skip_to (size_t new_x, size_t pos, const float *samples) {
|
|
if(new_x > d_current_x) {
|
|
size_t dist = std::min(size_t(39), new_x - d_current_x);
|
|
for(size_t i = 0; i < dist; i++) {
|
|
set_pixel(new_x - dist + i, d_current_y, samples[pos - dist + i]);
|
|
}
|
|
}
|
|
d_current_x = new_x;
|
|
}
|
|
|
|
|
|
noaa_apt_sync_marker
|
|
noaa_apt_sink_impl::is_marker(size_t pos, const float *samples) {
|
|
size_t count_a = 0;
|
|
size_t count_b = 0;
|
|
|
|
for(size_t i = 0; i < 40; i++) {
|
|
float sample = samples[pos - 39 + i];
|
|
sample = sample - f_average;
|
|
if((sample > 0 && synca_seq[i]) || (sample < 0 && !syncb_seq[i])) {
|
|
count_a += 1;
|
|
}
|
|
if((sample > 0 && syncb_seq[i]) || (sample < 0 && !syncb_seq[i])) {
|
|
count_b += 1;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
if(count_a > 35) {
|
|
return noaa_apt_sync_marker::SYNC_A;
|
|
}
|
|
else if(count_b > 35) {
|
|
return noaa_apt_sync_marker::SYNC_B;
|
|
}
|
|
else {
|
|
return noaa_apt_sync_marker::NONE;
|
|
}
|
|
}
|
|
|
|
|
|
int
|
|
noaa_apt_sink_impl::work (int noutput_items,
|
|
gr_vector_const_void_star &input_items,
|
|
gr_vector_void_star &output_items)
|
|
{
|
|
const float *in = (const float *) input_items[0];
|
|
|
|
for (size_t i = d_history_length - 1; i < noutput_items + d_history_length - 1; i++) {
|
|
float sample = in[i];
|
|
|
|
f_max_level = std::fmax(f_max_level, sample);
|
|
f_min_level = std::fmin(f_min_level, sample);
|
|
|
|
// Update exponential smoothing average used in sync pattern detection
|
|
f_average = f_average_alpha * sample + (1.0 - f_average_alpha) * f_average;
|
|
|
|
if(d_synchronize_opt) {
|
|
if(is_marker(i, in) == noaa_apt_sync_marker::SYNC_A) {
|
|
skip_to(39, i, in);
|
|
if(!d_has_sync) {
|
|
f_max_level = 0.0;
|
|
f_min_level = 1.0;
|
|
d_has_sync = true;
|
|
}
|
|
}
|
|
else if(is_marker(i, in) == noaa_apt_sync_marker::SYNC_B) {
|
|
skip_to(d_width / 2 + 39, i, in);
|
|
if(!d_has_sync) {
|
|
f_max_level = 0.0;
|
|
f_min_level = 1.0;
|
|
d_has_sync = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
set_pixel(d_current_x, d_current_y, sample);
|
|
|
|
d_current_x += 1;
|
|
if(d_current_x >= d_width) {
|
|
d_current_y += 1;
|
|
d_current_x = 0;
|
|
|
|
if(d_current_y % d_row_write_threshold == 0) {
|
|
write_images();
|
|
}
|
|
|
|
if(d_current_y >= d_height) {
|
|
d_current_y = 0;
|
|
d_num_images += 1;
|
|
write_images();
|
|
init_images();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return noutput_items;
|
|
}
|
|
|
|
} /* namespace satnogs */
|
|
} /* namespace gr */
|