cv::Scalar colorLevel(int index, hsv::Levels levels) {
// TODO move these outside and pass as arguments?
int numColors = levels[0] * levels[1] * levels[2];
int numGrays = levels[2] + 1;
arma::ivec grays = arma::linspace<arma::ivec>(1, 256, numGrays);
if (index > numColors - 1) { // grays
int level = index - numColors;
int value = grays(level) - 1;
return cv::Scalar(value, value, value);
}
else { // colors
hsv::Levels indices = ind2sub(levels, index);
cv::Vec3f temp;
for (int i = 0; i < 3; i++) {
temp[i] = static_cast<float>(indices[i] + 1) / levels[i];
BOOST_ASSERT(temp[i] >= 0. and temp[i] <= 1.);
}
temp[0] *= 360.;
cv::Mat bgr(1, 1, CV_32FC3);
bgr.at<cv::Vec3f>(0) = temp;
cv::cvtColor(bgr, bgr, CV_HSV2BGR);
cv::Vec3f& val = bgr.at<cv::Vec3f>(0);
val *= 255.;
return cv::Scalar(val[0], val[1], val[2]);
}
}
int main() {
const size_t bufsize = 1024 * 1024 * 1;
fpga_con_t con;
fpga_con_init( &con, "131.159.28.113", 12340, 12350 );
bg_reader bgr( con.s );
// bg_reader bgr2( con.s );
char buf[4];
fpga_con_send( &con, buf, 4 );
const size_t rbuf_size = 10 * 1024;
char rbuf[rbuf_size];
// while( true ) {
//
//
// //size_t s = bgr.readPacket( rbuf, rbuf_size );
//
// //printf( "recv size: %zd\n", s );
//
// if( s < 1024 ) {
// break;
// }
//
// }
bgr.join();
// bgr2.join();
}
void Image::saveTGA(std::string const& path, float gamma) const
{
// Convert float RGBA to uint8 BGR.
std::vector<std::uint8_t> bgr(m_pixels.size() * 3);
for (std::size_t i = 0; i < m_pixels.size(); ++i)
{
std::size_t const idx = i * 3;
for (int c = 0; c < 3; ++c)
{
float const gamma_corrected = std::pow(m_pixels[i][2-c], 1.f / gamma);
float const mapped = std::max<float>(0.0f, std::min<float>(255.0f, 255.f * gamma_corrected));
bgr[idx+c] = uint8_t(mapped);
}
}
TgaHeader header;
header.size[0] = m_width;
header.size[1] = m_height;
std::ofstream f(path.c_str(), std::ios::binary);
if (!f)
{
std::cerr << "Cannot write image to '" << path << "'." << std::endl;
return;
}
f.write(reinterpret_cast<char const*>(&header), sizeof(header));
f.write(reinterpret_cast<char const*>(bgr.data()), bgr.size());
}
fixed
OrderedTask::CalcRequiredGlide(const AircraftState &aircraft,
const GlidePolar &glide_polar) const
{
TaskGlideRequired bgr(task_points, active_task_point, aircraft,
task_behaviour.glide, glide_polar);
return bgr.search(fixed_zero);
}
fixed
UnorderedTask::CalcRequiredGlide(const AircraftState &aircraft) const
{
TaskPoint *tp = GetActiveTaskPoint();
if (!tp) {
return fixed_zero;
}
TaskGlideRequired bgr(tp, aircraft, glide_polar);
return bgr.search(fixed_zero);
}
fixed
UnorderedTask::CalcRequiredGlide(const AircraftState &aircraft,
const GlidePolar &glide_polar) const
{
TaskPoint *tp = GetActiveTaskPoint();
if (tp == nullptr || !aircraft.location.IsValid())
return fixed(0);
TaskGlideRequired bgr(tp, aircraft, task_behaviour.glide, glide_polar);
return bgr.search(fixed(0));
}
//! Returns the color in 0xaabbggrr representation.
boost::uint32_t abgr() const
{
return alpha() << 24 | bgr();
}
void GenSOM::train(const multi_img &input, ProgressObserver *po)
{
std::cout << "Start feeding" << std::endl;
// matrices hold shuffled sequences of the input for number of iterations
int maxIter = config.maxIter;
cv::Mat_<int> shuffledY(1, maxIter);
cv::Mat_<int> shuffledX(1, maxIter);
// generate random sequence of the input x,y range
cv::RNG rng(config.seed);
rng.fill(shuffledY, cv::RNG::UNIFORM,
cv::Scalar(0), cv::Scalar(input.height));
rng.fill(shuffledX, cv::RNG::UNIFORM,
cv::Scalar(0), cv::Scalar(input.width));
// output percentage
unsigned int hundred = std::max<unsigned int>(maxIter/100, 100);
int percent = 1;
if (config.verbosity > 0) {
std::cout << " 0 %";
std::cout.flush();
}
long sumOfUpdates = 0;
// starting training (notifier needed by OpenCL impl.)
notifyTrainingStart();
cv::MatConstIterator_<int> itY = shuffledY.begin();
cv::MatConstIterator_<int> itX = shuffledX.begin();
for (int curIter = 0; curIter < maxIter; ++curIter, ++itX, ++itY)
{
// feed one sample
const multi_img::Pixel &vec = input(*itY, *itX);
sumOfUpdates += trainSingle(vec, curIter, maxIter);
// print progress (and maybe exit)
if ((config.verbosity > 0 || po) && (config.maxIter > 100)
&& ((curIter % hundred) == 0) && (percent < 100)) {
// send progress updates to observer or stdout
if (po) {
bool cont = po->update(curIter / (float)config.maxIter);
if (!cont) {
std::cerr << "Aborting training" << std::endl;
return;
}
} else {
std::cout << "\r " << (percent < 10 ? " " : "")
<< percent << " %";
std::cout.flush();
}
if (config.verbosity >= 2) {
std::cout << " Feed #" << curIter
<< ", avg. updates per iteration in the last "
<< (maxIter / hundred) << " iterations: "
<< ((double)sumOfUpdates / hundred)
<< std::endl;
sumOfUpdates = 0;
}
// print som each 20%
if (config.verbosity >= 3 && (percent % 20) == 0)
{
// TODO
/*multi_img somimg = som->export_2d();
std::ostringstream filename, filename2;
filename << "debug_som_";
filename << std::setfill('0') << std::setw(2);
filename << (ctr / (config.maxIter / 20));
somimg.write_out(filename.str());
filename2 << filename.str();
filename << "-rgb.png";
cv::imwrite(filename.str(), somimg.bgr() * 255.f);
if (!updateMap.empty()) {
cv::Mat3f upBGR(updateMap.rows, updateMap.cols);
cv::cvtColor(updateMap, upBGR, CV_GRAY2BGR);
for (cv::Mat3f::iterator it = upBGR.begin(); it != upBGR.end();++it)
if (*it == cv::Vec3f(0.f))
*it = cv::Vec3f(0.f, 0.f, 1.f);
filename2 << "-updates.png";
cv::imwrite(filename2.str(), upBGR * 255.f);
}*/
}
percent++;
}
}
if (config.verbosity > 0)
std::cout << "\r100 %" <<std::endl;
// finished training (notifier needed by OpenCL impl.)
notifyTrainingEnd();
std::cout <<"# Feeding done" <<std::endl;
if (!config.somFile.empty()) {
std::cout << "# writing SOM in binary format to \""
<< config.somFile << "\"" << std::endl;
saveFile(config.somFile);
}
if (config.verbosity > 2) {
cv::imwrite("debug_som.png", bgr(input.meta, input.maxval)*255.f);
}
}
