bool SphericalProjection::geoCoordinates( const int x, const int y,
const ViewportParams *viewport,
qreal& lon, qreal& lat,
GeoDataCoordinates::Unit unit ) const
{
const qreal inverseRadius = 1.0 / (qreal)(viewport->radius());
const qreal qx = +(qreal)( x - viewport->width() / 2 ) * inverseRadius;
const qreal qy = -(qreal)( y - viewport->height() / 2 ) * inverseRadius;
if ( 1 <= qx * qx + qy * qy ) {
return false;
}
const qreal qz = sqrt( 1 - qx * qx - qy * qy );
Quaternion qpos( 0.0, qx, qy, qz );
qpos.rotateAroundAxis( viewport->planetAxis() );
qpos.getSpherical( lon, lat );
if ( unit == GeoDataCoordinates::Degree ) {
lon *= RAD2DEG;
lat *= RAD2DEG;
}
return true;
}
void swirl_search_nearest(int explored_cells, Vec2 pos, vector<Transformable*>&result_sorted, int results_max)
{
//msgs("### starting swirl_search_nearest ###");
// will check n cells in a swirl
// will stop when at least 10 results are found
Vec2i qpos(pos / resolution);
//msg(qpos);
vector<Transformable*> result1;
unsigned int i = 0;
for (auto&a : spiral)
{
query(qpos + a, result1);
if (result1.size() > results_max || i > explored_cells)
{
//msgm("broke after explored_cells:", i, "results_max:", result1.size());
break; // add up result until it react amount
}
++i;
}
map<float, Transformable*> sorted;
for (auto&a : result1)
{
float dist = vectlensquared(pos - a->getPosition());
sorted[dist] = a;
}
for (auto&a : sorted)
result_sorted.push_back(a.second);
}
void swirl_search(int n, Vec2 pos, vector<Vec2>&result)
{
vector<Vec2i> spiral;
ulam_spiral(n, spiral);
Vec2i qpos(pos / resolution);
for (auto&a : spiral)
{
query(qpos + a, result);
}
}
void TestEndgameAccuracy(){
int i;
CNodeStats start,end, start1,end1,delta1;
CValue value;
// create computer
CComputerDefaults cd;
cd.booklevel=CComputerDefaults::kNoBook;
CPlayerComputer computer(cd);
start.Read();
for (i=0; i<nEndgames; i++) {
::nBBFlips=0;
bool fBlackMove=false;
Pos2 pos2;
pos2.Initialize(bds[i].board, fBlackMove);
computer.Clear();
if (printDetails > 1) {
pos2.Print();
}
start1.Read();
CMVK mvk;
CSearchInfo si=computer.DefaultSearchInfo(fBlackMove, CSearchInfo::kNeedValue+CSearchInfo::kNeedMove, 1e6, 0);
CQPosition qpos(pos2.GetBB(), pos2.BlackMove());
computer.GetChosen(si,qpos,mvk, true);
value=mvk.value/kStoneValue;
end1.Read();
delta1=end1-start1;
assertEquals(bds[i].nResultNoEmpties, value);
if (printDetails) {
std::cout << std::setw(2) << i;
std::cout << ": Value: " << std::setw(3) << value;
std::cout << ". Nodes: " << std::setw(6) << (int)delta1.Nodes();
std::cout << ". Board: " << bds[i].board << "\n";
if (printDetails > 1) {
std::cout << end1-start1 << "\n";
std::cout << "-------------------------------------------\n";
}
}
}
end.Read();
if (printDetails) {
std::cout << end-start << "\n";
}
}
void grid_index::swirl_search(int max_result, int ulams, Vec2 pos, vector<int>&result){
Vec2i qpos(pos * resolution);
//msgm("querying max", max_result,"items, for max", ulams,"ulams at", pos, "calculated cell", qpos);
unsigned int u = 0;
vector<Vec2i> ulam_test;
for (auto&a : spiral) {
ulam_test.push_back(a);
query(qpos + a, result);
++u;
if (result.size() > max_result || u >= ulams) {
//msg(ulam_test);
return;
}
}
}
extern void skin_surface_blit(SkinSurface *dst, SkinPos *pos, SkinSurface *src, SkinRect *rect, SkinBlitOp op)
{
#if 0
D("skin_surface_blit from %d (%d, %d) to %d: %d,%d,%d,%d", src->id, rect->pos.x, rect->pos.y, dst->id, rect->pos.x, rect->pos.y, rect->size.w, rect->size.h);
#endif
QRect qrect(rect->pos.x, rect->pos.y, rect->size.w, rect->size.h);
QPoint qpos(pos->x, pos->y);
QPainter::CompositionMode qop;
switch(op) {
default:
case SKIN_BLIT_COPY:
qop = QPainter::CompositionMode_Source;
break;
case SKIN_BLIT_SRCOVER:
qop = QPainter::CompositionMode_SourceOver;
break;
}
QSemaphore semaphore;
dst->window->blit(src->bitmap, &qrect, dst->bitmap, &qpos, &qop, &semaphore);
semaphore.acquire();
}
std::pair<bool, std::shared_ptr<file_md5_skel::skel_frame> > file_md5_skel::process_skel_frame( file_md5_anim::frame const & f, file_md5_anim::bound const & bbox, std::list<file_md5_anim::hierarchy> const & hier, std::list<file_md5_anim::baseframe> const & base ){
if( hier.size() != base.size() ){
assert( false && "hierarchy and baseframe size not equal" );
return { false, {} };
}
std::shared_ptr<skel_frame> sf( new skel_frame );
sf->_joints.resize( hier.size() );
auto it_hier = hier.begin();
auto it_base = base.begin();
int index_current_joint = 0;
while( it_hier != hier.end() ){
int frame_data_start_index = it_hier->_start_index;
int flag = it_hier->_flags;
//obtain rotation and position from base frame
float sf_pos[3];
float sf_rot[3];
for( int i = 0; i < 3; ++i ){
sf_pos[i] = it_base->_pos[i];
sf_rot[i] = it_base->_orient[i];
}
int offset = 0;
//update rotation and position from frame data if neccessary
for( int i = 0; i < 3; ++i ){
if( flag & (1<<i) ){
if( frame_data_start_index + offset >= f._data.size() ){
assert( false && "index access out of range" );
return { false, {} };
}
sf_pos[i] = f._data[ frame_data_start_index + offset ];
++offset;
}
}
for( int i = 0; i < 3; ++i ){
if( flag & (8<<i) ){
if( frame_data_start_index + offset >= f._data.size() ){
assert( false && "index access out of range" );
return { false, {} };
}
sf_rot[i] = f._data[ frame_data_start_index + offset ];
++offset;
}
}
//compute rotation quaternion
Quat sf_orient( sf_rot[0], sf_rot[1], sf_rot[2] );
sf_orient.NormalizeQuatCurrent();
int parent_joint_index = it_hier->_parent;
std::shared_ptr<joint_frame> jf( new joint_frame );
jf->_parent = parent_joint_index;
jf->_name = it_hier->_name;
if( parent_joint_index >= 0 ){
if( parent_joint_index >= sf->_joints.size() ){
assert( false && "parent joint index out of range." );
return { false, {} };
}
std::shared_ptr<joint_frame> parent_joint_frame = sf->_joints[ parent_joint_index ];
//chain transformation from parent joint
//update positions
Quat qpos( sf_pos[0], sf_pos[1], sf_pos[2], 0.0f );
Quat orient_inv = parent_joint_frame->_orient.Inverse();
orient_inv.NormalizeQuatCurrent();
Quat res = parent_joint_frame->_orient * qpos * orient_inv;
for( int i = 0; i < 3; ++i ){
jf->_pos[i] = parent_joint_frame->_pos[i] + res._quat[i];
}
//update orientation
jf->_orient = parent_joint_frame->_orient * sf_orient;
jf->_orient.NormalizeQuatCurrent();
}else{
//no parent, root joint
for( int i = 0; i < 3; ++i ){
jf->_pos[i] = sf_pos[i];
}
jf->_orient = sf_orient;
jf->_orient.NormalizeQuatCurrent();
}
// sf->_joints.push_back( jf );
sf->_joints[ index_current_joint ] = jf;
++it_hier;
++it_base;
++index_current_joint;
}
for( int i = 0; i < 3; ++i ){
sf->_bbox_lower[i] = bbox._min[i];
sf->_bbox_upper[i] = bbox._max[i];
}
return { true, sf };
}
void medVtkViewObserver::Execute(vtkObject *caller, unsigned long event, void *callData)
{
if(this->m_locked)
return;
if(!this->m_view)
return;
unsigned int layer = this->m_view->currentLayer();
switch(event)
{
case vtkImageView::CurrentPointChangedEvent:
{
const double *pos = this->view2d->GetCurrentPoint();
QVector3D qpos(doubleToQtVector3D(pos));
if(m_view->positionBeingViewedParameter())
m_view->positionBeingViewedParameter()->setValue(qpos);
break;
}
case vtkImageView2DCommand::CameraZoomEvent:
{
double zoom = this->view2d->GetZoom();
m_view->zoomParameter()->setValue(zoom);
break;
}
case vtkImageView2DCommand::CameraPanEvent:
{
const double *pan = this->view2d->GetPan();
QVector2D qpan (pan[0], pan[1]);
m_view->panParameter()->setValue(qpan);
break;
}
case vtkImageView::WindowLevelChangedEvent:
{
double level = this->view2d->GetColorLevel(layer);
double window = this->view2d->GetColorWindow(layer);
QList<QVariant> wl;
wl.append(QVariant(window));
wl.append(QVariant(level));
if(m_view->windowLevelParameter(layer))
m_view->windowLevelParameter(layer)->setValues(wl);
break;
}
case vtkCommand::InteractionEvent:
{
double *pos = this->view3d->GetRenderer()->GetActiveCamera()->GetPosition();
double *vup = this->view3d->GetRenderer()->GetActiveCamera()->GetViewUp();
double *foc = this->view3d->GetRenderer()->GetActiveCamera()->GetFocalPoint();
double ps = this->view3d->GetRenderer()->GetActiveCamera()->GetParallelScale();
QVector3D position(doubleToQtVector3D(pos));
QVector3D viewup(doubleToQtVector3D(vup));
QVector3D focal(doubleToQtVector3D(foc));
QList<QVariant> cam;
cam.append(QVariant(position));
cam.append(QVariant(viewup));
cam.append(QVariant(focal));
cam.append(QVariant(ps));
if(m_view->cameraParameter())
m_view->cameraParameter()->setValues(cam);
break;
}
case vtkCommand::KeyPressEvent:
{
vtkRenderWindowInteractor *windowInteractor = static_cast<vtkRenderWindowInteractor*>(caller);
if (windowInteractor->GetShiftKey())
{
m_view->rubberBandZoomParameter()->setValue(true);
}
break;
}
case vtkCommand::KeyReleaseEvent:
{
vtkRenderWindowInteractor *windowInteractor = static_cast<vtkRenderWindowInteractor*>(caller);
if (!windowInteractor->GetShiftKey())
{
m_view->rubberBandZoomParameter()->setValue(false);
}
break;
}
}// switch end
}
