//时间的标准化,把通用时标准到UTC时间的儒略时,作为标准时间接口 //m_satState=0实时状态 m_satState=1模拟状态 //m_timeState=0北京时间 m_timeState=1UTC cJulian cJulianNormal(CommonTime m_time,int m_satState/*卫星状态*/,int m_timeState/*时间状态*/) { cJulian m_real(m_time.year,m_time.month,m_time.day, m_time.hour,m_time.minute,m_time.second); if(m_satState==0)//实时 m_real.addHour(-8);//由于实时状态下系统是北京时间 else//模拟 { if(m_timeState==0) { m_real.addHour(-8); } } return m_real; }
void CSatNote::SunPosShow(CommonTime m_realTime) { cJulian m_real(m_realTime.year,m_realTime.month,m_realTime.day, m_realTime.hour,m_realTime.minute,m_realTime.second); m_real.addHour(-8); cSun sun(m_real); m_sunLon=sun.GetSunPos().getPoint3D().x; m_sunLat=sun.GetSunPos().getPoint3D().y; CString m_lon,m_lat; m_lon.Format("%.3lf",m_sunLon); m_lat.Format("%.3lf",m_sunLat); CString str1,str2; str1="经度:"; str2="纬度:"; m_lon=str1+m_lon+"度"; m_lat=str2+m_lat+"度"; GetDlgItem(IDC_NOTE_LONG)->SetWindowText(m_lon); GetDlgItem(IDC_NOTE_LAT)->SetWindowText(m_lat); }
bool symmetry_detection_3d::run(viennamesh::algorithm_handle &) { // // std::cout << "dynamic: " << jacobi_polynom<double>(4,2,2) << std::endl; // std::cout << "static: " << static_jacobi_polynom<double,4>(2,2) << std::endl; // // return true; mesh_handle input_mesh = get_required_input<mesh_handle>("mesh"); int geometric_dimension = viennagrid::geometric_dimension( input_mesh() ); int cell_dimension = viennagrid::cell_dimension( input_mesh() ); data_handle<int> p = get_required_input<int>("p"); data_handle<double> relative_integrate_tolerance = get_required_input<double>("relative_integrate_tolerance"); data_handle<double> absolute_integrate_tolerance = get_required_input<double>("absolute_integrate_tolerance"); // data_handle<int> max_iteration_count = get_required_input<int>("max_iteration_count"); data_handle<double> mirror_symmetry_tolerance = get_required_input<double>("mirror_symmetry_tolerance"); data_handle<double> rotational_symmetry_tolerance = get_required_input<double>("rotational_symmetry_tolerance"); if (geometric_dimension != 3) return false; if (cell_dimension != 2) return false; typedef viennagrid::mesh MeshType; typedef point PointType; typedef viennagrid::result_of::const_vertex_range<MeshType>::type ConstVertexRangeType; typedef viennagrid::result_of::iterator<ConstVertexRangeType>::type ConstVertexRangeIterator; double max_size = 0.0; { ConstVertexRangeType vertices(input_mesh()); for (ConstVertexRangeIterator vit = vertices.begin(); vit != vertices.end(); ++vit) { double cur_size = viennagrid::norm_2( viennagrid::get_point(*vit) ); if (cur_size > max_size) max_size = cur_size; } } info(1) << "Before start" << std::endl; MeshType mesh; viennagrid::copy( input_mesh(), mesh ); viennagrid::scale( mesh, 1.0/max_size ); info(1) << "After copy/scale" << std::endl; viennautils::Timer timer; timer.start(); RealGeneralizedMoment m_real(2*p(), mesh); // , relative_integrate_tolerance(), absolute_integrate_tolerance(), max_iteration_count()); info(1) << "After calculating generalized moment (!!! took " << timer.get() << "sec !!!)" << std::endl; double sphere_radius = 1.0; if (get_input<double>("sphere_radius").valid()) sphere_radius = get_input<double>("sphere_radius")(); MeshType sphere; viennagrid::make_sphere_hull( sphere, viennagrid::make_point(0,0,0), sphere_radius, 4 ); viennagrid::quantity_field gradient_field_real(0, 1); gradient_field_real.set_name("gradient_real"); ConstVertexRangeType vertices(sphere); for (ConstVertexRangeIterator vit = vertices.begin(); vit != vertices.end(); ++vit) { PointType const & pt = viennagrid::get_point(*vit); double theta; double phi; double r; to_spherical(pt, theta, phi, r); double grad_real = m_real.grad(theta, phi, 1e-2); gradient_field_real.set(*vit, grad_real); } // { // int bench_count = 100000; // std::vector<double> v(bench_count); // viennamesh::LoggingStack s("bench"); // // for (int i = 0; i != bench_count; ++i) // v[i] = m_real.grad(i*0.1, i*0.2, 1e-2); // } info(1) << "After calculating sphere" << std::endl; set_output("sphere", sphere); set_output("mesh", mesh); quantity_field_handle quantities = make_data<viennagrid::quantity_field>(); quantities.set(gradient_field_real); set_output("sphere_quantities", quantities); // m_real.print(); // std::cout << std::endl; // std::cout << "m_real hast mirror symmetry: " << std::boolalpha << m_real.z_mirror_symmetry( mirror_symmetry_tolerance() ) << std::endl; // m_real.rotation_symmetry_angles(); // // rotational_symmetry_tolerance() ); // std::cout << std::endl; data_handle<viennamesh_point> rotation_vector = get_input<viennamesh_point>("rotation_vector"); data_handle<int> rotational_frequencies = get_input<int>("rotational_frequencies"); if (rotation_vector.valid()) { for (int i = 0; i != rotation_vector.size(); ++i) { point new_z = rotation_vector(i); info(1) << "Using rotation vector " << new_z << std::endl; RealGeneralizedMoment rotated_m = m_real.get_rotated(new_z); // rotated_m.print(); // std::cout << std::endl; info(1) << "rotated_m (z = "<< new_z << ") hast mirror symmetry: " << std::boolalpha << rotated_m.z_mirror_symmetry( mirror_symmetry_tolerance() ) << std::endl; // rotated_m.rotation_symmetry_angles(); // rotated_m.rotation_symmetry_angles( rotational_symmetry_tolerance() ); rotated_m.check_rotation_symmetry(M_PI); if (rotational_frequencies.valid()) { for (int i = 0; i != rotational_frequencies.size(); ++i) { int rotational_frequency = rotational_frequencies(i); double angle = 2*M_PI/rotational_frequency; info(1) << "Using rotational frequency " << rotational_frequency << " (angle = " << angle << ") error = " << rotated_m.check_rotation_symmetry(angle) << std::endl; } } } } return true; }
int interpolateInt(m_real t, int s, int e) { m_real f=m_real(s)*(1.0-t)+m_real(e)*t; return ROUND(f); }