void OrbFeatures(cv::Mat in_image)
{
cv::OrbFeatureDetector orb(500);
std::vector< cv::KeyPoint > keypoints;
orb.detect(in_image, keypoints);
cv::OrbDescriptorExtractor extractor;
cv::Mat descriptors;
cv::Mat training_descriptors(1, extractor.descriptorSize(), extractor.descriptorType());
extractor.compute(in_image, keypoints, descriptors);
training_descriptors.push_back(descriptors);
cv::BOWKMeansTrainer bow_trainer(2);
bow_trainer.add(descriptors);
cv::Mat vocabulary = bow_trainer.cluster();
}
int main(int argc, char *argv[]) {
#if ENABLE_CORBA
Astro::OrbSingleton orb(argc, argv);
#endif /* ENABLE_CORBA */
int c;
while (EOF != (c = getopt(argc, argv, "d")))
switch (c) {
case 'd':
debuglevel = LOG_DEBUG;
break;
}
CppUnit::TextUi::TestRunner runner;
CppUnit::TestFactoryRegistry ®istry
= CppUnit::TestFactoryRegistry::getRegistry();
runner.addTest(registry.makeTest());
bool wasSuccessful = runner.run("", false);
return (wasSuccessful) ? 0 : 1;
}
int main() {
int tmp;
#if 0
tmp = orb();
assert (tmp == 27 || tmp == 0);
#endif
tmp = orbtrue();
assert (tmp ==27);
tmp = orbfalse();
assert (tmp ==27);
tmp = orbfalse2();
assert (tmp ==27);
tmp = ors();
assert (tmp ==27);
tmp = orus();
assert (tmp == 65539);
return 0;
}
bool orbMatch(cv::Mat& inImageScene, cv::Mat& inImageObj, cv::Rect& outBoundingBox, unsigned int inMinMatches=2, float inKnnRatio=0.7)
{
//vector of keypoints
std::vector< cv::KeyPoint > keypointsO;
std::vector< cv::KeyPoint > keypointsS;
cv::Mat descriptors_object, descriptors_scene;
cv::Mat outImg;
inImageScene.copyTo(outImg);
//-- Step 1: Extract keypoints
cv::OrbFeatureDetector orb(ORB_NUM_FEATURES);
orb.detect(inImageScene, keypointsS);
if (keypointsS.size() < ORB_MIN_MATCHES)
{
//cout << "Not enough keypoints S, object not found>" << keypointsS.size() << endl;
return false;
}
orb.detect(inImageObj, keypointsO);
if (keypointsO.size() < ORB_MIN_MATCHES)
{
//cout << "Not enough keypoints O, object not found>" << keypointsO.size() << endl;
return false;
}
//Calculate descriptors (feature vectors)
cv::OrbDescriptorExtractor extractor;
extractor.compute(inImageScene, keypointsS, descriptors_scene);
extractor.compute(inImageObj, keypointsO, descriptors_object);
//Matching descriptor vectors using FLANN matcher
cv::BFMatcher matcher;
//descriptors_scene.size(), keypointsO.size(), keypointsS.size();
std::vector< std::vector< cv::DMatch > > matches;
matcher.knnMatch(descriptors_object, descriptors_scene, matches, 2);
std::vector< cv::DMatch > good_matches;
good_matches.reserve(matches.size());
for (size_t i = 0; i < matches.size(); ++i)
{
if (matches[i].size() < 3)
continue;
const cv::DMatch &m1 = matches[i][0];
const cv::DMatch &m2 = matches[i][1];
if (m1.distance <= inKnnRatio * m2.distance)
good_matches.push_back(m1);
}
if ((good_matches.size() >= inMinMatches))
{
std::vector< cv::Point2f > obj;
std::vector< cv::Point2f > scene;
for (unsigned int i = 0; i < good_matches.size(); i++)
{
// Get the keypoints from the good matches
obj.push_back(keypointsO[good_matches[i].queryIdx].pt);
scene.push_back(keypointsS[good_matches[i].trainIdx].pt);
}
cv::Mat H = findHomography(obj, scene, CV_RANSAC);
// Get the corners from the image_1 ( the object to be "detected" )
std::vector< cv::Point2f > obj_corners(4);
obj_corners[0] = cvPoint(0, 0); obj_corners[1] = cvPoint(inImageObj.cols, 0);
obj_corners[2] = cvPoint(inImageObj.cols, inImageObj.rows); obj_corners[3] = cvPoint(0, inImageObj.rows);
std::vector< cv::Point2f > scene_corners(4);
perspectiveTransform(obj_corners, scene_corners, H);
// Draw lines between the corners (the mapped object in the scene - image_2 )
line(outImg, scene_corners[0], scene_corners[1], cv::Scalar(255, 0, 0), 2); //TOP line
line(outImg, scene_corners[1], scene_corners[2], cv::Scalar(255, 0, 0), 2);
line(outImg, scene_corners[2], scene_corners[3], cv::Scalar(255, 0, 0), 2);
line(outImg, scene_corners[3], scene_corners[0], cv::Scalar(255, 0, 0), 2);
//imshow("Scene", outImg);
//imshow("Obj", inImageObj);
//cvWaitKey(5);
return true;
}
return false;
}
void CVStereo::rectify() {
// Find interest points using ORB...
std::vector<cv::KeyPoint> keypoints[2];
cv::Mat descriptors[2];
// Parameters for ORB features
int nfeatures=500;
float scaleFactor=1.2f;
int nlevels=8;
int edgeThreshold=31;
int firstLevel=0;
int WTA_K=2;
int scoreType=cv::ORB::HARRIS_SCORE;
int patchSize=31;
for (int i = 0; i < 2; i++) {
cv::Mat grayCV;
cv::Mat grayCV8;
cv::ORB orb(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel,
WTA_K, scoreType, patchSize);
cv::cvtColor(original[i], grayCV, CV_BGR2GRAY);
grayCV.convertTo(grayCV8, CV_8U);
orb(grayCV8, cv::Mat(), keypoints[i], descriptors[i]);
}
// Match interest points...
int normType = cv::NORM_HAMMING;
if (WTA_K == 3 || WTA_K == 4) {
normType = cv::NORM_HAMMING2;
}
std::vector<cv::DMatch> matchList;
cv::BFMatcher matcher(normType, true);
matcher.match(descriptors[0], descriptors[1], matchList);
// Compute the fundatmental matrix...
// Convert the matched points into an appropriate format
int numPoints = matchList.size();
std::vector<cv::Point2f> points[2] {
std::vector<cv::Point2f>(numPoints),
std::vector<cv::Point2f>(numPoints)
};
for (int pt = 0; pt < numPoints; pt++) {
points[0][pt] = cv::Point2f(
keypoints[0][matchList[pt].queryIdx].pt.x,
keypoints[0][matchList[pt].queryIdx].pt.y);
}
for (int pt = 0; pt < numPoints; pt++) {
points[1][pt] = cv::Point2f(
keypoints[1][matchList[pt].trainIdx].pt.x,
keypoints[1][matchList[pt].trainIdx].pt.y);
}
warp(points);
}
void unit_drawer::redraw_unit (const unit & u) const
{
unit_animation_component & ac = u.anim_comp();
map_location loc = u.get_location();
int side = u.side();
bool hidden = u.get_hidden();
bool is_flying = u.is_flying();
map_location::DIRECTION facing = u.facing();
int hitpoints = u.hitpoints();
int max_hitpoints = u.max_hitpoints();
int movement_left = u.movement_left();
int total_movement = u.total_movement();
bool can_recruit = u.can_recruit();
bool can_advance = u.can_advance();
int experience = u.experience();
int max_experience = u.max_experience();
bool emit_zoc = u.emits_zoc();
SDL_Color hp_color=u.hp_color();
SDL_Color xp_color=u.xp_color();
std::string ellipse=u.image_ellipse();
if ( hidden || is_blindfolded || !u.is_visible_to_team(viewing_team_ref,map, show_everything) )
{
ac.clear_haloes();
if(ac.anim_) {
ac.anim_->update_last_draw_time();
}
return;
}
if (!ac.anim_) {
ac.set_standing();
if (!ac.anim_) return;
}
if (ac.refreshing_) return;
ac.refreshing_ = true;
ac.anim_->update_last_draw_time();
frame_parameters params;
const t_translation::t_terrain terrain = map.get_terrain(loc);
const terrain_type& terrain_info = map.get_terrain_info(terrain);
// do not set to 0 so we can distinguish the flying from the "not on submerge terrain"
// instead use -1.0 (as in "negative depth", it will be ignored by rendering)
params.submerge= is_flying ? -1.0 : terrain_info.unit_submerge();
if (u.invisible(loc) &&
params.highlight_ratio > 0.5) {
params.highlight_ratio = 0.5;
}
if (loc == sel_hex && params.highlight_ratio == 1.0) {
params.highlight_ratio = 1.5;
}
int height_adjust = static_cast<int>(terrain_info.unit_height_adjust() * zoom_factor);
if (is_flying && height_adjust < 0) {
height_adjust = 0;
}
params.y -= height_adjust;
params.halo_y -= height_adjust;
int red = 0,green = 0,blue = 0,tints = 0;
double blend_ratio = 0;
// Add future colored states here
if(u.poisoned()) {
green += 255;
blend_ratio += 0.25;
tints += 1;
}
if(u.slowed()) {
red += 191;
green += 191;
blue += 255;
blend_ratio += 0.25;
tints += 1;
}
if(tints > 0) {
params.blend_with = disp.rgb((red/tints),(green/tints),(blue/tints));
params.blend_ratio = ((blend_ratio/tints));
}
//hackish : see unit_frame::merge_parameters
// we use image_mod on the primary image
// and halo_mod on secondary images and all haloes
params.image_mod = u.image_mods();
params.halo_mod = u.TC_image_mods();
params.image= u.default_anim_image();
if(u.incapacitated()) params.image_mod +="~GS()";
params.primary_frame = t_true;
const frame_parameters adjusted_params = ac.anim_->get_current_params(params);
const map_location dst = loc.get_direction(facing);
const int xsrc = disp.get_location_x(loc);
const int ysrc = disp.get_location_y(loc);
const int xdst = disp.get_location_x(dst);
const int ydst = disp.get_location_y(dst);
const int x = static_cast<int>(adjusted_params.offset * xdst + (1.0-adjusted_params.offset) * xsrc) + hex_size_by_2;
const int y = static_cast<int>(adjusted_params.offset * ydst + (1.0-adjusted_params.offset) * ysrc) + hex_size_by_2;
bool has_halo = ac.unit_halo_ && ac.unit_halo_->valid();
if(!has_halo && !u.image_halo().empty()) {
ac.unit_halo_ = halo_man.add(0, 0, u.image_halo()+u.TC_image_mods(), map_location(-1, -1));
}
if(has_halo && u.image_halo().empty()) {
halo_man.remove(ac.unit_halo_);
ac.unit_halo_ = halo::handle(); //halo::NO_HALO;
} else if(has_halo) {
halo_man.set_location(ac.unit_halo_, x, y - height_adjust);
}
// We draw bars only if wanted, visible on the map view
bool draw_bars = ac.draw_bars_ ;
if (draw_bars) {
SDL_Rect unit_rect = sdl::create_rect(xsrc, ysrc +adjusted_params.y, hex_size, hex_size);
draw_bars = sdl::rects_overlap(unit_rect, disp.map_outside_area());
}
#ifdef SDL_GPU
sdl::timage ellipse_front;
sdl::timage ellipse_back;
#else
surface ellipse_front(nullptr);
surface ellipse_back(nullptr);
#endif
int ellipse_floating = 0;
// Always show the ellipse for selected units
if(draw_bars && (preferences::show_side_colors() || sel_hex == loc)) {
if(adjusted_params.submerge > 0.0) {
// The division by 2 seems to have no real meaning,
// It just works fine with the current center of ellipse
// and prevent a too large adjust if submerge = 1.0
ellipse_floating = static_cast<int>(adjusted_params.submerge * hex_size_by_2);
}
if(ellipse.empty()){
ellipse="misc/ellipse";
}
if(ellipse != "none") {
// check if the unit has a ZoC or can recruit
const char* const nozoc = emit_zoc ? "" : "nozoc-";
const char* const leader = can_recruit ? "leader-" : "";
const char* const selected = sel_hex == loc ? "selected-" : "";
// Load the ellipse parts recolored to match team color
char buf[100];
std::string tc=team::get_side_color_index(side);
#ifdef SDL_GPU
snprintf(buf,sizeof(buf),"%s-%s%s%stop.png~RC(ellipse_red>%s)",ellipse.c_str(),leader,nozoc,selected,tc.c_str());
ellipse_back = image::get_texture(image::locator(buf), image::SCALED_TO_ZOOM);
snprintf(buf,sizeof(buf),"%s-%s%s%sbottom.png~RC(ellipse_red>%s)",ellipse.c_str(),leader,nozoc,selected,tc.c_str());
ellipse_front = image::get_texture(image::locator(buf), image::SCALED_TO_ZOOM);
#else
snprintf(buf,sizeof(buf),"%s-%s%s%stop.png~RC(ellipse_red>%s)",ellipse.c_str(),leader,nozoc,selected,tc.c_str());
ellipse_back.assign(image::get_image(image::locator(buf), image::SCALED_TO_ZOOM));
snprintf(buf,sizeof(buf),"%s-%s%s%sbottom.png~RC(ellipse_red>%s)",ellipse.c_str(),leader,nozoc,selected,tc.c_str());
ellipse_front.assign(image::get_image(image::locator(buf), image::SCALED_TO_ZOOM));
#endif
}
}
#ifdef SDL_GPU
if (!ellipse_back.null()) {
//disp.drawing_buffer_add(display::LAYER_UNIT_BG, loc,
disp.drawing_buffer_add(display::LAYER_UNIT_FIRST, loc,
xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_back);
}
if (!ellipse_front.null()) {
//disp.drawing_buffer_add(display::LAYER_UNIT_FG, loc,
disp.drawing_buffer_add(display::LAYER_UNIT_FIRST, loc,
xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_front);
}
#else
if (ellipse_back != nullptr) {
//disp.drawing_buffer_add(display::LAYER_UNIT_BG, loc,
disp.drawing_buffer_add(display::LAYER_UNIT_FIRST, loc,
xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_back);
}
if (ellipse_front != nullptr) {
//disp.drawing_buffer_add(display::LAYER_UNIT_FG, loc,
disp.drawing_buffer_add(display::LAYER_UNIT_FIRST, loc,
xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_front);
}
#endif
if(draw_bars) {
const image::locator* orb_img = nullptr;
const surface unit_img = image::get_image(u.default_anim_image(), image::SCALED_TO_ZOOM);
const int xoff = (hex_size - unit_img->w)/2;
const int yoff = (hex_size - unit_img->h)/2;
/*static*/ const image::locator partmoved_orb(game_config::images::orb + "~RC(magenta>" +
preferences::partial_color() + ")" );
/*static*/ const image::locator moved_orb(game_config::images::orb + "~RC(magenta>" +
preferences::moved_color() + ")" );
/*static*/ const image::locator ally_orb(game_config::images::orb + "~RC(magenta>" +
preferences::allied_color() + ")" );
/*static*/ const image::locator enemy_orb(game_config::images::orb + "~RC(magenta>" +
preferences::enemy_color() + ")" );
/*static*/ const image::locator unmoved_orb(game_config::images::orb + "~RC(magenta>" +
preferences::unmoved_color() + ")" );
const std::string* energy_file = &game_config::images::energy;
if(size_t(side) != viewing_team+1) {
if(disp.team_valid() &&
viewing_team_ref.is_enemy(side)) {
if (preferences::show_enemy_orb() && !u.incapacitated())
orb_img = &enemy_orb;
else
orb_img = nullptr;
} else {
if (preferences::show_allied_orb())
orb_img = &ally_orb;
else orb_img = nullptr;
}
} else {
if (preferences::show_moved_orb())
orb_img = &moved_orb;
else orb_img = nullptr;
if(playing_team == viewing_team && !u.user_end_turn()) {
if (movement_left == total_movement) {
if (preferences::show_unmoved_orb())
orb_img = &unmoved_orb;
else orb_img = nullptr;
} else if ( dc.unit_can_move(u) ) {
if (preferences::show_partial_orb())
orb_img = &partmoved_orb;
else orb_img = nullptr;
}
}
}
if (orb_img != nullptr) {
surface orb(image::get_image(*orb_img,image::SCALED_TO_ZOOM));
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc, xsrc + xoff, ysrc + yoff + adjusted_params.y, orb);
}
double unit_energy = 0.0;
if(max_hitpoints > 0) {
unit_energy = double(hitpoints)/double(max_hitpoints);
}
const int bar_shift = static_cast<int>(-5*zoom_factor);
const int hp_bar_height = static_cast<int>(max_hitpoints * u.hp_bar_scaling());
const fixed_t bar_alpha = (loc == mouse_hex || loc == sel_hex) ? ftofxp(1.0): ftofxp(0.8);
draw_bar(*energy_file, xsrc+xoff+bar_shift, ysrc+yoff+adjusted_params.y,
loc, hp_bar_height, unit_energy,hp_color, bar_alpha);
if(experience > 0 && can_advance) {
const double filled = double(experience)/double(max_experience);
const int xp_bar_height = static_cast<int>(max_experience * u.xp_bar_scaling() / std::max<int>(u.level(),1));
draw_bar(*energy_file, xsrc+xoff, ysrc+yoff+adjusted_params.y,
loc, xp_bar_height, filled, xp_color, bar_alpha);
}
if (can_recruit) {
surface crown(image::get_image(u.leader_crown(),image::SCALED_TO_ZOOM));
if(!crown.null()) {
//if(bar_alpha != ftofxp(1.0)) {
// crown = adjust_surface_alpha(crown, bar_alpha);
//}
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc, xsrc+xoff, ysrc+yoff+adjusted_params.y, crown);
}
}
for(std::vector<std::string>::const_iterator ov = u.overlays().begin(); ov != u.overlays().end(); ++ov) {
#ifdef SDL_GPU
const sdl::timage ov_img(image::get_texture(*ov, image::SCALED_TO_ZOOM));
if(!ov_img.null()) {
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc, xsrc, ysrc +adjusted_params.y, ov_img);
}
#else
const surface ov_img(image::get_image(*ov, image::SCALED_TO_ZOOM));
if(ov_img != nullptr) {
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc, xsrc+xoff, ysrc+yoff+adjusted_params.y, ov_img);
}
#endif
}
}
// Smooth unit movements from terrain of different elevation.
// Do this separately from above so that the health bar doesn't go up and down.
const t_translation::t_terrain terrain_dst = map.get_terrain(dst);
const terrain_type& terrain_dst_info = map.get_terrain_info(terrain_dst);
int height_adjust_unit = static_cast<int>((terrain_info.unit_height_adjust() * (1.0 - adjusted_params.offset) +
terrain_dst_info.unit_height_adjust() * adjusted_params.offset) *
zoom_factor);
if (is_flying && height_adjust_unit < 0) {
height_adjust_unit = 0;
}
params.y -= height_adjust_unit - height_adjust;
params.halo_y -= height_adjust_unit - height_adjust;
ac.anim_->redraw(params, halo_man);
ac.refreshing_ = false;
}
int main(int argc, const char* argv[])
{
cv::Mat img1_src = cv::imread("../../Pictures/move1.jpg", CV_LOAD_IMAGE_GRAYSCALE);
cv::Mat img2_src = cv::imread("../../Pictures/move2.jpg", CV_LOAD_IMAGE_GRAYSCALE);
cv::gpu::GpuMat img1;
cv::gpu::GpuMat img2;
cv::Mat img1_dst;
cv::Mat img2_dst;
// Value for keypoints
std::vector<cv::KeyPoint> keypoints1;
std::vector<cv::KeyPoint> keypoints2;
cv::gpu::GpuMat keypoints1GPU;
cv::gpu::GpuMat keypoints2GPU;
// Value for descriptor
cv::Mat descriptor1;
cv::Mat descriptor2;
cv::gpu::GpuMat descriptors1GPU;
cv::gpu::GpuMat descriptors2GPU;
// Creat Object of FeatureDetector
cv::Ptr<cv::FeatureDetector> detector = new cv::ORB(200, 1.25f, 4, 7, 0, 2, 0, 7);
// Create Object of DescriptionExtractor
cv::Ptr<cv::DescriptorExtractor> extractor = new cv::ORB(200, 1.25f, 4, 7, 0, 2, 0, 7);
// orb detector and extractor
cv::gpu::ORB_GPU orb(200);
// Create Object of DescriptorMatcher
cv::Ptr<cv::DescriptorMatcher> matcher = cv::DescriptorMatcher::create("BruteForce-Hamming");
// Create Object of DescriptorMatcher
cv::gpu::BruteForceMatcher_GPU< cv::Hamming > gpumatcher;
// values of how maching
std::vector<cv::DMatch> dmatch;
std::vector<cv::DMatch> dmatchOK;
std::vector< std::vector< cv::DMatch> > matches;
// CPU
cv::TickMeter cpumeter;
cpumeter.start();
// detect keypoints
detector->detect(img1_src, keypoints1);
detector->detect(img2_src, keypoints2);
// compute descripter
extractor->compute(img1_src, keypoints1, descriptor1);
extractor->compute(img2_src, keypoints2, descriptor2);
// match descripter
matcher->match(descriptor1, descriptor2, dmatch);
// get minimal distance of match
double min_dist = DBL_MAX;
for (int i = 0; i < (int)dmatch.size(); i++){
double dist = dmatch[i].distance;
if (dist < min_dist){
min_dist = dist;
}
}
if (min_dist < 1.0)
{
min_dist = 1.0;
}
// set threshold
const double threshold = 2.0 * min_dist;
for (int i = 0; i < (int)dmatch.size(); i++){
if (dmatch[i].distance < threshold){
dmatchOK.push_back(dmatch[i]);
}
}
cpumeter.stop();
// show result
std::cout << "ORB (CPU): " << cpumeter.getTimeMilli() << "ms" << std::endl;
std::cout << "keypoints1 : " << keypoints1.size() << " keypoints2 :" << keypoints2.size() << std::endl;
// upload src to gpu
img1.upload(img1_src);
img2.upload(img2_src);
// clock
cv::TickMeter gpumeter;
gpumeter.start();
// get feauters
orb(img1, cv::gpu::GpuMat(), keypoints1GPU, descriptors1GPU);
orb(img2, cv::gpu::GpuMat(), keypoints2GPU, descriptors2GPU);
// matching
gpumatcher.knnMatch(descriptors1GPU, descriptors2GPU, matches, 2);
// threshold
std::vector< cv::DMatch > good_matches;
for(int k = 0; k < std::min(descriptors1GPU.rows-1,(int) matches.size()); k++)
{
if((matches[k][0].distance < 0.6*(matches[k][1].distance)) && ((int) matches[k].size()<=2 && (int) matches[k].size()>0))
{
good_matches.push_back(matches[k][0]);
}
}
gpumeter.stop();
// download dst to host
img1.download(img1_dst);
img2.download(img2_dst);
// show result
std::cout << "ORB (GPU): " << gpumeter.getTimeMilli() << "ms" << std::endl;
orb.downloadKeyPoints(keypoints1GPU, keypoints1);
orb.downloadKeyPoints(keypoints2GPU, keypoints2);
std::cout << "keypoint1 :" << keypoints1.size() << " keypoint2 :" << keypoints2.size() << std::endl;
std::cout << "GPU/CPU*100: " << cpumeter.getTimeMilli() / gpumeter.getTimeMilli() *100<< " %" << std::endl;
return 0;
}
void drawable_unit::redraw_unit (display & disp) const
{
const display_context & dc = disp.get_disp_context();
const gamemap &map = dc.map();
const std::vector<team> &teams = dc.teams();
const team & viewing_team = teams[disp.viewing_team()];
unit_animation_component & ac = *anim_comp_;
if ( hidden_ || disp.is_blindfolded() || !is_visible_to_team(viewing_team,map, disp.show_everything()) )
{
ac.clear_haloes();
if(ac.anim_) {
ac.anim_->update_last_draw_time();
}
return;
}
if (!ac.anim_) {
ac.set_standing();
if (!ac.anim_) return;
}
if (ac.refreshing_) return;
ac.refreshing_ = true;
ac.anim_->update_last_draw_time();
frame_parameters params;
const t_translation::t_terrain terrain = map.get_terrain(loc_);
const terrain_type& terrain_info = map.get_terrain_info(terrain);
// do not set to 0 so we can distinguish the flying from the "not on submerge terrain"
// instead use -1.0 (as in "negative depth", it will be ignored by rendering)
params.submerge= is_flying() ? -1.0 : terrain_info.unit_submerge();
if (invisible(loc_) &&
params.highlight_ratio > 0.5) {
params.highlight_ratio = 0.5;
}
if (loc_ == disp.selected_hex() && params.highlight_ratio == 1.0) {
params.highlight_ratio = 1.5;
}
int height_adjust = static_cast<int>(terrain_info.unit_height_adjust() * disp.get_zoom_factor());
if (is_flying() && height_adjust < 0) {
height_adjust = 0;
}
params.y -= height_adjust;
params.halo_y -= height_adjust;
int red = 0,green = 0,blue = 0,tints = 0;
double blend_ratio = 0;
// Add future colored states here
if(get_state(STATE_POISONED)) {
green += 255;
blend_ratio += 0.25;
tints += 1;
}
if(get_state(STATE_SLOWED)) {
red += 191;
green += 191;
blue += 255;
blend_ratio += 0.25;
tints += 1;
}
if(tints > 0) {
params.blend_with = disp.rgb((red/tints),(green/tints),(blue/tints));
params.blend_ratio = ((blend_ratio/tints));
}
//hackish : see unit_frame::merge_parameters
// we use image_mod on the primary image
// and halo_mod on secondary images and all haloes
params.image_mod = image_mods();
params.halo_mod = TC_image_mods();
params.image= absolute_image();
if(get_state(STATE_PETRIFIED)) params.image_mod +="~GS()";
params.primary_frame = t_true;
const frame_parameters adjusted_params = ac.anim_->get_current_params(params);
const map_location dst = loc_.get_direction(facing_);
const int xsrc = disp.get_location_x(loc_);
const int ysrc = disp.get_location_y(loc_);
const int xdst = disp.get_location_x(dst);
const int ydst = disp.get_location_y(dst);
int d2 = disp.hex_size() / 2;
const int x = static_cast<int>(adjusted_params.offset * xdst + (1.0-adjusted_params.offset) * xsrc) + d2;
const int y = static_cast<int>(adjusted_params.offset * ydst + (1.0-adjusted_params.offset) * ysrc) + d2;
if(ac.unit_halo_ == halo::NO_HALO && !image_halo().empty()) {
ac.unit_halo_ = halo::add(0, 0, image_halo()+TC_image_mods(), map_location(-1, -1));
}
if(ac.unit_halo_ != halo::NO_HALO && image_halo().empty()) {
halo::remove(ac.unit_halo_);
ac.unit_halo_ = halo::NO_HALO;
} else if(ac.unit_halo_ != halo::NO_HALO) {
halo::set_location(ac.unit_halo_, x, y - height_adjust);
}
// We draw bars only if wanted, visible on the map view
bool draw_bars = ac.draw_bars_ ;
if (draw_bars) {
const int d = disp.hex_size();
SDL_Rect unit_rect = sdl::create_rect(xsrc, ysrc +adjusted_params.y, d, d);
draw_bars = sdl::rects_overlap(unit_rect, disp.map_outside_area());
}
surface ellipse_front(NULL);
surface ellipse_back(NULL);
int ellipse_floating = 0;
// Always show the ellipse for selected units
if(draw_bars && (preferences::show_side_colors() || disp.selected_hex() == loc_)) {
if(adjusted_params.submerge > 0.0) {
// The division by 2 seems to have no real meaning,
// It just works fine with the current center of ellipse
// and prevent a too large adjust if submerge = 1.0
ellipse_floating = static_cast<int>(adjusted_params.submerge * disp.hex_size() / 2);
}
std::string ellipse=image_ellipse();
if(ellipse.empty()){
ellipse="misc/ellipse";
}
if(ellipse != "none") {
// check if the unit has a ZoC or can recruit
const char* const nozoc = emit_zoc_ ? "" : "nozoc-";
const char* const leader = can_recruit() ? "leader-" : "";
const char* const selected = disp.selected_hex() == loc_ ? "selected-" : "";
// Load the ellipse parts recolored to match team color
char buf[100];
std::string tc=team::get_side_color_index(side_);
snprintf(buf,sizeof(buf),"%s-%s%s%stop.png~RC(ellipse_red>%s)",ellipse.c_str(),leader,nozoc,selected,tc.c_str());
ellipse_back.assign(image::get_image(image::locator(buf), image::SCALED_TO_ZOOM));
snprintf(buf,sizeof(buf),"%s-%s%s%sbottom.png~RC(ellipse_red>%s)",ellipse.c_str(),leader,nozoc,selected,tc.c_str());
ellipse_front.assign(image::get_image(image::locator(buf), image::SCALED_TO_ZOOM));
}
}
if (ellipse_back != NULL) {
//disp.drawing_buffer_add(display::LAYER_UNIT_BG, loc,
disp.drawing_buffer_add(display::LAYER_UNIT_FIRST, loc_,
xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_back);
}
if (ellipse_front != NULL) {
//disp.drawing_buffer_add(display::LAYER_UNIT_FG, loc,
disp.drawing_buffer_add(display::LAYER_UNIT_FIRST, loc_,
xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_front);
}
if(draw_bars) {
const image::locator* orb_img = NULL;
/*static*/ const image::locator partmoved_orb(game_config::images::orb + "~RC(magenta>" +
preferences::partial_color() + ")" );
/*static*/ const image::locator moved_orb(game_config::images::orb + "~RC(magenta>" +
preferences::moved_color() + ")" );
/*static*/ const image::locator ally_orb(game_config::images::orb + "~RC(magenta>" +
preferences::allied_color() + ")" );
/*static*/ const image::locator enemy_orb(game_config::images::orb + "~RC(magenta>" +
preferences::enemy_color() + ")" );
/*static*/ const image::locator unmoved_orb(game_config::images::orb + "~RC(magenta>" +
preferences::unmoved_color() + ")" );
const std::string* energy_file = &game_config::images::energy;
if(size_t(side()) != disp.viewing_team()+1) {
if(disp.team_valid() &&
viewing_team.is_enemy(side())) {
if (preferences::show_enemy_orb() && !get_state(STATE_PETRIFIED))
orb_img = &enemy_orb;
else
orb_img = NULL;
} else {
if (preferences::show_allied_orb())
orb_img = &ally_orb;
else orb_img = NULL;
}
} else {
if (preferences::show_moved_orb())
orb_img = &moved_orb;
else orb_img = NULL;
if(disp.playing_team() == disp.viewing_team() && !user_end_turn()) {
if (movement_left() == total_movement()) {
if (preferences::show_unmoved_orb())
orb_img = &unmoved_orb;
else orb_img = NULL;
} else if ( dc.unit_can_move(*this) ) {
if (preferences::show_partial_orb())
orb_img = &partmoved_orb;
else orb_img = NULL;
}
}
}
if (orb_img != NULL) {
surface orb(image::get_image(*orb_img,image::SCALED_TO_ZOOM));
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc_, xsrc, ysrc +adjusted_params.y, orb);
}
double unit_energy = 0.0;
if(max_hitpoints() > 0) {
unit_energy = double(hitpoints())/double(max_hitpoints());
}
const int bar_shift = static_cast<int>(-5*disp.get_zoom_factor());
const int hp_bar_height = static_cast<int>(max_hitpoints() * hp_bar_scaling_);
const fixed_t bar_alpha = (loc_ == disp.mouseover_hex() || loc_ == disp.selected_hex()) ? ftofxp(1.0): ftofxp(0.8);
disp.draw_bar(*energy_file, xsrc+bar_shift, ysrc +adjusted_params.y,
loc_, hp_bar_height, unit_energy,hp_color(), bar_alpha);
if(experience() > 0 && can_advance()) {
const double filled = double(experience())/double(max_experience());
const int xp_bar_height = static_cast<int>(max_experience() * xp_bar_scaling_ / std::max<int>(level_,1));
SDL_Color color=xp_color();
disp.draw_bar(*energy_file, xsrc, ysrc +adjusted_params.y,
loc_, xp_bar_height, filled, color, bar_alpha);
}
if (can_recruit()) {
surface crown(image::get_image(leader_crown(),image::SCALED_TO_ZOOM));
if(!crown.null()) {
//if(bar_alpha != ftofxp(1.0)) {
// crown = adjust_surface_alpha(crown, bar_alpha);
//}
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc_, xsrc, ysrc +adjusted_params.y, crown);
}
}
for(std::vector<std::string>::const_iterator ov = overlays().begin(); ov != overlays().end(); ++ov) {
const surface ov_img(image::get_image(*ov, image::SCALED_TO_ZOOM));
if(ov_img != NULL) {
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc_, xsrc, ysrc +adjusted_params.y, ov_img);
}
}
}
// Smooth unit movements from terrain of different elevation.
// Do this separately from above so that the health bar doesn't go up and down.
const t_translation::t_terrain terrain_dst = map.get_terrain(dst);
const terrain_type& terrain_dst_info = map.get_terrain_info(terrain_dst);
int height_adjust_unit = static_cast<int>((terrain_info.unit_height_adjust() * (1.0 - adjusted_params.offset) +
terrain_dst_info.unit_height_adjust() * adjusted_params.offset) *
disp.get_zoom_factor());
if (is_flying() && height_adjust_unit < 0) {
height_adjust_unit = 0;
}
params.y -= height_adjust_unit - height_adjust;
params.halo_y -= height_adjust_unit - height_adjust;
ac.anim_->redraw(params);
ac.refreshing_ = false;
}
int process(const ecto::tendrils& inputs, const ecto::tendrils& outputs) {
// case 0: more elongated that image_, case 1: morevertical, case 2: same ratio
int ratio_case;
float ratio2d_x, ratio2d_y;
if (points3d_in_->cols * image_->rows > points3d_in_->rows * image_->cols) {
ratio2d_x = float(points3d_in_->cols) / float(image_->cols);
ratio2d_y = ratio2d_x;
ratio_case = 0;
} else if (points3d_in_->cols * image_->rows < points3d_in_->rows * image_->cols) {
ratio2d_y = float(points3d_in_->rows) / float(image_->rows);
ratio2d_x = ratio2d_y;
ratio_case = 1;
} else {
ratio2d_y = float(points3d_in_->rows) / float(image_->rows);
ratio2d_x = ratio2d_y;
ratio_case = 2;
}
// Create a mask to fins the keypoints
cv::Mat_<uchar> mask(image_->size());
if (!mask_->empty()) {
switch (ratio_case) {
case 0: {
cv::Mat sub_mask_top = mask.rowRange(0, float(mask_->rows) / ratio2d_x);
cv::resize(*mask_, sub_mask_top, sub_mask_top.size());
mask.rowRange(sub_mask_top.rows, mask.rows).setTo(0);
break;
}
case 1: {
cv::Mat sub_mask_left = mask.colRange(0, float(mask_->cols) / ratio2d_y);
cv::resize(*mask_, sub_mask_left, sub_mask_left.size());
mask.colRange(sub_mask_left.cols, mask.cols).setTo(0);
break;
}
default:
cv::resize(*mask_, mask, mask.size());
break;
}
}
// Find keypoints in the current image
#if (CV_MAJOR_VERSION ==3)
cv::Ptr<cv::ORB> orb = cv::ORB::create(*n_features_, *scale_factor_, *n_levels_);
#elif (CV_MAJOR_VERSION == 2) && (CV_MINOR_VERSION >= 4)
cv::ORB orb = cv::ORB(*n_features_, *scale_factor_, *n_levels_);
#else
cv::ORB::CommonParams orb_params;
orb_params.first_level_ = 0;
orb_params.n_levels_ = *n_levels_;
orb_params.scale_factor_ = *scale_factor_;
cv::ORB orb = cv::ORB(*n_features_, orb_params);
#endif
cv::Mat descriptors;
if (*use_fast_) {
cv::FAST(*image_, *keypoints_, 30);
#if (CV_MAJOR_VERSION ==3)
orb->detectAndCompute(*image_, mask, *keypoints_, descriptors, true);
#else
orb(*image_, mask, *keypoints_, descriptors, true);
#endif
} else {
#if (CV_MAJOR_VERSION ==3)
orb->detectAndCompute(*image_, mask, *keypoints_, descriptors);
#else
orb(*image_, mask, *keypoints_, descriptors);
#endif
}
// Remove bad keypoints
std::vector<cv::Vec2f> points;
std::vector<cv::Vec3f> points3d;
points.reserve(keypoints_->size());
points3d.reserve(keypoints_->size());
descriptors_->create(descriptors.size(), descriptors.type());
for (size_t i = 0; i < keypoints_->size(); ++i) {
int x = (*keypoints_)[i].pt.x * ratio2d_x;
int y = (*keypoints_)[i].pt.y * ratio2d_y;
if ((x >= points3d_in_->cols) || (y >= points3d_in_->rows))
continue;
points.push_back(cv::Vec2f((*keypoints_)[i].pt.x, (*keypoints_)[i].pt.y));
points3d.push_back(points3d_in_->at<cv::Vec3f>(y, x));
descriptors.row(i).copyTo(descriptors_->row(points3d.size() - 1));
}
// Store the points
if (points.empty()) {
points_->release();
points3d_out_->release();
descriptors_->release();
} else {
*points_ = cv::Mat(points, true);
*points3d_out_ = cv::Mat(points3d, true);
descriptors.rowRange(0, points3d.size()).copyTo(*descriptors_);
}
return ecto::OK;
}