/** @brief 获取当前时间值 */ void StatManager::endTime() { struct timeval tv; dure_time_end = clkTime_end = getClockTime(); gettimeofday(&tv,NULL); sysTime_end = tv.tv_sec; }
/** * Constructor for the Themis Vis Camera Model * * @param lab Pvl label from an Odyssey Themis VIS image. * * @throws IException::User - The image does not appear to be a Themis * VIS image * @internal * @history 2010-08-04 Jeannie Walldren - Added NAIF error check. */ ThemisVisCamera::ThemisVisCamera(Pvl &lab) : PushFrameCamera(lab) { NaifStatus::CheckErrors(); // Set up the camera characteristics // LoadFrameMounting("M01_SPACECRAFT","M01_THEMIS_VIS"); // Changed Focal Length from 203.9 (millimeters????) to 202.059, per request from // Christopher Edwards ([email protected]) at ASU, on 2/18/11. SetFocalLength(202.059); SetPixelPitch(0.009); PvlGroup &inst = lab.findGroup("Instrument", Pvl::Traverse); // make sure it is a themis vis image if(inst["InstrumentId"][0] != "THEMIS_VIS") { string msg = "The image does not appear to be a Themis Vis Image"; throw IException(IException::User, msg, _FILEINFO_); } // Get necessary variables p_exposureDur = inst["ExposureDuration"]; p_interframeDelay = inst["InterframeDelay"]; int sumMode = inst["SpatialSumming"]; // Get the start and end time double et; QString stime = inst["SpacecraftClockCount"]; et = getClockTime(stime).Et(); double offset = inst["SpacecraftClockOffset"]; p_etStart = et + offset - ((p_exposureDur / 1000.0) / 2.0); p_nframes = inst["NumFramelets"]; // Get the keywords from labels PvlGroup &bandBin = lab.findGroup("BandBin", Pvl::Traverse); PvlKeyword &orgBand = bandBin["OriginalBand"]; for(int i = 0; i < orgBand.size(); i++) { p_originalBand.push_back(toInt(orgBand[i])); } // Setup detector map double frameRate = p_interframeDelay; PushFrameCameraDetectorMap *dmap = new PushFrameCameraDetectorMap(this, p_etStart, frameRate, 192); dmap->SetDetectorSampleSumming(sumMode); dmap->SetDetectorLineSumming(sumMode); // Setup focal plane map CameraFocalPlaneMap *focalMap = new CameraFocalPlaneMap(this, naifIkCode()); focalMap->SetDetectorOrigin(512.5, 512.5); // Setup distortion map new ThemisVisDistortionMap(this); // Setup the ground and sky map bool evenFramelets = (inst["Framelets"][0] == "Even"); new PushFrameCameraGroundMap(this, evenFramelets); new CameraSkyMap(this); LoadCache(); NaifStatus::CheckErrors(); }
/** @brief 提取当前系统时间和硬件时钟时钟时间并保存,以秒为单位 */ void StatManager::beginTime() { struct timeval tv; dure_time_start = clkTime_start = getClockTime(); gettimeofday(&tv,NULL); sysTime_start = tv.tv_sec; power_time_start = clkTime_start; }
void Timer::dump(ostream& s, Size depth) const { BALL_DUMP_STREAM_PREFIX(s); BALL_DUMP_DEPTH(s, depth); BALL_DUMP_CLASS_HEADER(s, Timer, this); BALL_DUMP_DEPTH(s, depth); s << "CPU speed: " << cpu_speed_ << endl; BALL_DUMP_DEPTH(s, depth); s << "is running: " << (is_running_ ? "true" : "false") << endl; BALL_DUMP_DEPTH(s, depth); s << "last clock seconds: " << last_secs_ << endl; BALL_DUMP_DEPTH(s, depth); s << "last user seconds: " << last_usecs_ << endl; BALL_DUMP_DEPTH(s, depth); s << "last user time: " << last_user_time_ << endl; BALL_DUMP_DEPTH(s, depth); s << "last system time: " << last_system_time_ << endl; BALL_DUMP_DEPTH(s, depth); s << "current clock seconds: " << current_secs_ << endl; BALL_DUMP_DEPTH(s, depth); s << "current user seconds: " << current_usecs_ << endl; BALL_DUMP_DEPTH(s, depth); s << "current user time: " << current_user_time_ << endl; BALL_DUMP_DEPTH(s, depth); s << "current system time: " << current_system_time_ << endl; BALL_DUMP_DEPTH(s, depth); s << "effective clock time: " << getClockTime() << endl; BALL_DUMP_DEPTH(s, depth); s << "effective user time: " << getUserTime() << endl; BALL_DUMP_DEPTH(s, depth); s << "effective system time: " << getSystemTime() << endl; BALL_DUMP_DEPTH(s, depth); s << "effective CPU time: " << getCPUTime() << endl; BALL_DUMP_STREAM_SUFFIX(s); }
/** * Creates a Hirise Camera Model * * @param lab Pvl label from the iamge * @internal * @history 2011-05-03 Jeannie Walldren - Added NAIF error check. */ HiriseCamera::HiriseCamera(Cube &cube) : LineScanCamera(cube) { NaifStatus::CheckErrors(); // Setup camera characteristics from instrument and frame kernel SetFocalLength(); SetPixelPitch(); //LoadFrameMounting("MRO_SPACECRAFT", "MRO_HIRISE_OPTICAL_AXIS"); instrumentRotation()->SetFrame(-74690); // Get required keywords from instrument group Pvl &lab = *cube.label(); PvlGroup &inst = lab.findGroup("Instrument", Pvl::Traverse); int tdiMode = inst["Tdi"]; double binMode = inst["Summing"]; int chan = inst["ChannelNumber"]; int cpmm = inst["CpmmNumber"]; double deltaLineTimerCount = inst["DeltaLineTimerCount"]; QString stime = inst["SpacecraftClockStartCount"]; // Convert CPMM number to CCD number static int cpmm2ccd[] = {0, 1, 2, 3, 12, 4, 10, 11, 5, 13, 6, 7, 8, 9}; int ccd = cpmm2ccd[cpmm]; // Compute the line rate, convert to seconds, and multiply by the // downtrack summing double unBinnedRate = (74.0 + (deltaLineTimerCount / 16.0)) / 1000000.0; double lineRate = unBinnedRate * binMode; // Convert the spacecraft clock count to ephemeris time SpiceDouble et; // The -74999 is the code to select the transformation from // high-precision MRO SCLK to ET et = getClockTime(stime, -74999).Et(); // Adjust the start time so that it is the effective time for // the first line in the image file. Note that on 2006-03-29, this // time is now subtracted as opposed to adding it. The computed start // time in the EDR is at the first serial line. et -= unBinnedRate * (((double) tdiMode / 2.0) - 0.5); // Effective observation // time for all the TDI lines used for the // first line before doing binning et += unBinnedRate * (((double) binMode / 2.0) - 0.5); // Effective observation time of the first line // in the image file, which is possibly binned // Compute effective line number within the CCD (in pixels) for the // given TDI mode. // This is the "centered" 0-based line number, where line 0 is the // center of the detector array and line numbers decrease going // towards the serial readout. Line number +64 sees a spot // on the ground before line number 0 or -64. double ccdLine_c = -64.0 + ((double) tdiMode / 2.0); // Setup detector map for transform of image pixels to detector position // CameraDetectorMap *detectorMap = // new LineScanCameraDetectorMap(this,et,lineRate); LineScanCameraDetectorMap *detectorMap = new LineScanCameraDetectorMap(this, et, lineRate); detectorMap->SetDetectorSampleSumming(binMode); detectorMap->SetDetectorLineSumming(binMode); if(chan == 0) { detectorMap->SetStartingDetectorSample(1025.0); } // Setup focal plane map for transform of detector position to // focal plane x/y. This will read the appropriate CCD // transformation coefficients from the instrument kernel CameraFocalPlaneMap *focalMap = new CameraFocalPlaneMap(this, -74600 - ccd); focalMap->SetDetectorOrigin(1024.5, 0.0); focalMap->SetDetectorOffset(0.0, ccdLine_c); // Setup distortion map. This will read the optical distortion // coefficients from the instrument kernel CameraDistortionMap *distortionMap = new CameraDistortionMap(this); distortionMap->SetDistortion(naifIkCode()); // Setup the ground and sky map to transform undistorted focal // plane x/y to lat/lon or ra/dec respectively. new LineScanCameraGroundMap(this); new LineScanCameraSkyMap(this); LoadCache(); NaifStatus::CheckErrors(); }
int main(int argc, char** argv) { (void) argc; (void) argv; /*srand(time(NULL));*/ #ifdef WIN32 { LARGE_INTEGER divisor; QueryPerformanceFrequency(&divisor); clockDivisor = divisor.QuadPart; } #else clockDivisor = CLOCKS_PER_SEC; #endif printf("Starting\nClock divisor: %lu\n", clockDivisor); struct graphics g = { #ifdef SHOWKEYS .width = 100, .height = 100, #else .width = 1200, .height = 900, #endif }; initiateGraphics(&g, "Test window"); if(!g.window) goto CLEANUP; /*thread t;*/ /*newThread(test, NULL, &t);*/ clockType frameStart, frameEnd, gameStart; getClockTime(&frameStart); initLogic(); loadEntities(); loadTileTextures(); initializeWorld(); initializeBullets(); initializeItems(); initializeItemFunctions(); luaStart(); getClockTime(&gameStart); while(1){ cameraTick(); renderGraphics(&g); oldMouseState = mouseState; mouseState = SDL_GetMouseState(&mouseX, &mouseY); if(oldMouseState != mouseState){ mouseEvent(); } for(SDL_Event event; SDL_PollEvent(&event);){ switch(event.type){ case SDL_QUIT: goto CLEANUP; case SDL_KEYDOWN: case SDL_KEYUP: if(event.key.keysym.scancode == 0x14) goto CLEANUP; //TODO keyEvent(event.key); break; } } getClockTime(&frameEnd); frameTime = getDiffClock(frameStart, frameEnd); appTime = getDiffClock(gameStart, frameEnd); frameStart = frameEnd; gameUpdate(); } CLEANUP: luaEnd(); uninitializeItems(); uninitializeItemFunctions(); uninitializeBullets(); uninitializeWorld(); unloadTileTextures(); unloadEntities(); destroyGraphics(&g); return 0; } float normalRandomFloat(){ return ((float) rand()) / ((float) RAND_MAX); } float randomFloat(float a, float b){ float diff = b - a; return a + normalRandomFloat() * diff; }
/** * Constructor for the LRO NAC Camera Model * * @param lab Pvl Label to create the camera model from * * @internal * @history 2011-05-03 Jeannie Walldren - Added NAIF error check. */ LroNarrowAngleCamera::LroNarrowAngleCamera(Cube &cube) : LineScanCamera(cube) { NaifStatus::CheckErrors(); // Set up the camera info from ik/iak kernels SetFocalLength(); SetPixelPitch(); double constantTimeOffset = 0.0, additionalPreroll = 0.0, additiveLineTimeError = 0.0, multiplicativeLineTimeError = 0.0; QString ikernKey = "INS" + toString(naifIkCode()) + "_CONSTANT_TIME_OFFSET"; constantTimeOffset = getDouble(ikernKey); ikernKey = "INS" + toString(naifIkCode()) + "_ADDITIONAL_PREROLL"; additionalPreroll = getDouble(ikernKey); ikernKey = "INS" + toString(naifIkCode()) + "_ADDITIVE_LINE_ERROR"; additiveLineTimeError = getDouble(ikernKey); ikernKey = "INS" + toString(naifIkCode()) + "_MULTIPLI_LINE_ERROR"; multiplicativeLineTimeError = getDouble(ikernKey); // Get the start time from labels Pvl &lab = *cube.label(); PvlGroup &inst = lab.findGroup("Instrument", Pvl::Traverse); QString stime = inst["SpacecraftClockPrerollCount"]; SpiceDouble etStart; if(stime != "NULL") { etStart = getClockTime(stime).Et(); } else { etStart = iTime((QString)inst["PrerollTime"]).Et(); } // Get other info from labels double csum = inst["SpatialSumming"]; double lineRate = (double) inst["LineExposureDuration"] / 1000.0; double ss = inst["SampleFirstPixel"]; ss += 1.0; lineRate *= 1.0 + multiplicativeLineTimeError; lineRate += additiveLineTimeError; etStart += additionalPreroll * lineRate; etStart += constantTimeOffset; setTime(etStart); // Setup detector map LineScanCameraDetectorMap *detectorMap = new LineScanCameraDetectorMap(this, etStart, lineRate); detectorMap->SetDetectorSampleSumming(csum); detectorMap->SetStartingDetectorSample(ss); // Setup focal plane map CameraFocalPlaneMap *focalMap = new CameraFocalPlaneMap(this, naifIkCode()); // Retrieve boresight location from instrument kernel (IK) (addendum?) ikernKey = "INS" + toString(naifIkCode()) + "_BORESIGHT_SAMPLE"; double sampleBoreSight = getDouble(ikernKey); ikernKey = "INS" + toString(naifIkCode()) + "_BORESIGHT_LINE"; double lineBoreSight = getDouble(ikernKey); focalMap->SetDetectorOrigin(sampleBoreSight, lineBoreSight); focalMap->SetDetectorOffset(0.0, 0.0); // Setup distortion map LroNarrowAngleDistortionMap *distMap = new LroNarrowAngleDistortionMap(this); distMap->SetDistortion(naifIkCode()); // Setup the ground and sky map new LineScanCameraGroundMap(this); new LineScanCameraSkyMap(this); LoadCache(); NaifStatus::CheckErrors(); }
/** * @brief Initialize the MDIS camera model for NAC and WAC * * This constructor reads the Messenger/MDIS instrument addendum for many of * its default parameters. * * This camera model does not support subframes of jailbar imaging modes. * An exception is thrown in those cases. * * @param lab Pvl label from a Messenger MDIS image. * * @throws iException::User - "Subframe imaging mode is not supported" * @throws iException::User - "Jail bar observations are not supported" * @throws iException::User - "New MDIS/NAC distortion model invalidates * previous SPICE - you must rerun spiceinit to get new * kernels" * @internal * @history 2011-05-03 Jeannie Walldren - Added NAIF error check. * */ MdisCamera::MdisCamera(Pvl &lab) : FramingCamera(lab) { NaifStatus::CheckErrors(); // Set up detector constants const int MdisWac(-236800); // const int MdisNac(-236820); PvlGroup &inst = lab.findGroup("Instrument", Pvl::Traverse); // Clarification on MDIS subframe image mode provides us the ability to // support this mode now. The entire MDIS frame is geometrically valid // but only portions of the full frame actually contain image data. The // portions outside subframes should be NULL and not interfere in // downstream processing, such as mosaics. #if defined(MDIS_SUBFRAMES_UNSUPPORTED) int subFrameMode = inst["SubFrameMode"]; if(subFrameMode != 0) { string msg = "Subframe imaging mode is not supported!"; throw iException::Message(iException::User, msg, _FILEINFO_); } #endif // According to the MDIS team, this is nothing to be concerned with and // should be treated as other normal observations. So the test to // disallow it has been effectively removed 2007-09-05 (KJB). #if defined(MDIS_JAILBARS_UNSUPPORTED) int jailBars = inst["JailBars"]; if(jailBars != 0) { string msg = "Jail bar observations are not currently supported!"; throw iException::Message(iException::Programmer, msg, _FILEINFO_); } #endif // Determine filter number. Only conditional code required for // NAC and WAC support! int filterNumber(0); // Default appropriate for MDIS-NAC if(naifIkCode() == MdisWac) { PvlGroup &bandBin = lab.findGroup("BandBin", Pvl::Traverse); filterNumber = bandBin["Number"]; } // Set up instrument and filter code strings QString ikCode = toString(naifIkCode()); int fnCode(naifIkCode() - filterNumber); QString filterCode = toString(fnCode); QString ikernKey; // Fetch the frame translations from the instrument kernels ikernKey = "INS" + ikCode + "_REFERENCE_FRAME"; QString baseFrame = getString(ikernKey); ikernKey = "INS" + filterCode + "_FRAME"; QString ikFrame = getString(ikernKey); // Set up the camera info from ik/iak kernels // Turns out (2008-01-17) the WAC has different focal lengths for // each filter. Added to the instrument kernel (IAK) on this date. // Add temperature dependant focal length SetFocalLength(computeFocalLength(filterCode, lab)); SetPixelPitch(); // Removed by Jeff Anderson. The refactor of the SPICE class // uses frames always so this is no longer needed // LoadFrameMounting(baseFrame, ikFrame, false); // Get the start time from labels as the starting image time plus half // the exposure duration (in <MS>) to get pointing attitude. // !!NOTE: The ephemeris time MUST be set prior to creating the // cache (CreateCache) because the kernels are all unloaded // after the cache is done and this operation will fail!! QString stime = inst["SpacecraftClockCount"]; double exposureDuration = ((double) inst["ExposureDuration"]) / 1000.0;// divide by 1000 to convert to seconds iTime etStart = getClockTime(stime); // Setup camera detector map CameraDetectorMap *detMap = new CameraDetectorMap(this); // Setup focal plane map, and detector origin for the instrument that // may have a filter (WAC only!). CameraFocalPlaneMap *focalMap = new CameraFocalPlaneMap(this, fnCode); // Retrieve boresight location from instrument kernel (IK) (addendum?) ikernKey = "INS" + ikCode + "_BORESIGHT_SAMPLE"; double sampleBoreSight = getDouble(ikernKey); ikernKey = "INS" + ikCode + "_BORESIGHT_LINE"; double lineBoreSight = getDouble(ikernKey); // Apply the boresight focalMap->SetDetectorOrigin(sampleBoreSight, lineBoreSight); // Determine summing. MDIS has two sources of summing or binning. // One is performed in the FPU and the in the MP, post-observation, // on-board after coming out of the FPGAs, where the FPU binning is // performed. The FPU binning was programmed incorrectly and the // actual pixels from the detector are peculiar. Hence, I have // designed this camera model such that the offsets can be managed // external to the code. See the MDIS instrument kernel addendum // in $ISIS3DATA/messenger/kernels/iak/mdisAddendum???.ti for the // offsets for *each* detector. Note that an offset is only applied // when FPU binning is performed. int fpuBinMode = inst["FpuBinningMode"]; int pixelBinMode = inst["PixelBinningMode"]; int summing = ((pixelBinMode == 0) ? 1 : pixelBinMode); // FPU binning was performed, retrieve the FPU binning offsets and // apply them to the focal plane mapping. if(fpuBinMode == 1) { #if defined(USE_FPU_BINNING_OFFSETS) ikernKey = "INS" + ikCode + "_FPUBIN_START_SAMPLE"; double fpuStartingSample = getDouble(ikernKey); detMap->SetStartingDetectorSample(fpuStartingSample); ikernKey = "INS" + ikCode + "_FPUBIN_START_LINE"; double fpuStartingLine = getDouble(ikernKey); detMap->SetStartingDetectorLine(fpuStartingLine); #endif summing *= 2; } // Set summing/binning modes as an accumulation of FPU and MP binning. detMap->SetDetectorLineSumming(summing); detMap->SetDetectorSampleSumming(summing); // Setup distortion map. As of 2007/12/06, we now have an actual model. // Note that this model supports distinct distortion for each WAC filter. // See $ISIS3DATA/messenger/kernels/iak/mdisAddendumXXX.ti or possibly // $ISIS3DATA/messenger/kernels/ik/msgr_mdis_vXXX.ti for the *_OD_K // parameters. // NAC has a new implementation of its distortion contributed by // Scott Turner and Lillian Nguyen at JHUAPL. // (2010/10/06) The WAC now uses the same disortion model implementation. // Valid Taylor Series parameters are in versions msgr_mdis_v120.ti IK // and above. Note fnCode works for NAC as well as long as // filterNumber stays at 0 for the NAC only! try { TaylorCameraDistortionMap *distortionMap = new TaylorCameraDistortionMap(this); distortionMap->SetDistortion(fnCode); } catch(IException &ie) { string msg = "New MDIS NAC/WAC distortion models will invalidate previous " "SPICE - you may need to rerun spiceinit to get new kernels"; throw IException(ie, IException::User, msg, _FILEINFO_); } // Setup the ground and sky map new CameraGroundMap(this); new CameraSkyMap(this); // Create a cache and grab spice info since it does not change for // a framing camera (fixed spacecraft position and pointing) after, // of course applying the gimble offset which is handled in the SPICE // kernels (thank you!). Note this was done automagically in the // SetEpheremisTime call above. IMPORTANT that it be done prior to // creating the cache since all kernels are unloaded, essentially // clearing the pool and whacking the frames definitions, required to iTime centerTime = etStart + (exposureDuration / 2.0); setTime(centerTime); LoadCache(); NaifStatus::CheckErrors(); }
void update_ui_snow( double time_step, bool windy ) { pp::Vec2d *v, f; pp::Vec2d *pt; double size; double dist_from_push, p_dist; pp::Vec2d push_vector; int i; double push_timestep, time; time = getClockTime(); push_vector.x = 0; push_vector.y = 0; push_timestep = 0; if ( push_position_initialized ) { push_vector.x = push_position.x - last_push_position.x; push_vector.y = push_position.y - last_push_position.y; push_timestep = time - last_update_time; } last_push_position = push_position; last_update_time = time; for ( i=0; i<num_particles; i++) { pt = &particles[i].pt; v = &particles[i].vel; size = particles[i].size; f.x = 0; f.y = 0; /* Mouse push and gravity */ dist_from_push = (pow((pt->x - push_position.x), 2) + pow((pt->y - push_position.y), 2)); if ( push_timestep > 0 ) { f.x = PUSH_FACTOR * push_vector.x / push_timestep; f.y = PUSH_FACTOR * push_vector.y / push_timestep; f.x = min(MAX_PUSH_FORCE,f.x); f.x = max(-MAX_PUSH_FORCE,f.x); f.y = min(MAX_PUSH_FORCE,f.y); f.y = max(-MAX_PUSH_FORCE,f.y); f.x *= 1.0/(PUSH_DIST_DECAY*dist_from_push + 1) * size/PARTICLE_SIZE_RANGE; f.y *= 1.0/(PUSH_DIST_DECAY*dist_from_push + 1) * size/PARTICLE_SIZE_RANGE; } /* Update velocity */ v->x += ( f.x + ( windy ? WIND_FORCE : 0.0 ) - v->x * AIR_DRAG ) * time_step; v->y += ( f.y - GRAVITY_FACTOR - v->y * AIR_DRAG ) * time_step; /* Update position */ pt->x += v->x * time_step * ( size / PARTICLE_SIZE_RANGE ); pt->y += v->y * time_step * ( size / PARTICLE_SIZE_RANGE ); if ( pt->x < 0 ) { pt->x = 1; } else if ( pt->x > 1 ) { pt->x = 0.0; } } /* Kill off & regenerate particles */ for (i=0; i<num_particles; i++) { particle_t *p = &particles[i]; if (p->pt.y < -0.05) { /* If we have an excess of particles, kill off with 50% probability */ if ( num_particles > BASE_NUM_PARTICLES && frand() > 0.5 ) { /* Delete the particle */ *p = particles[num_particles-1]; num_particles -= 1; } else { p->pt.x = frand(); p->pt.y = 1+frand()*BASE_VELOCITY; p_dist = frand(); p->size = PARTICLE_MIN_SIZE + ( 1.0 - p_dist ) * PARTICLE_SIZE_RANGE; p->vel.x = 0; p->vel.y = -BASE_VELOCITY-p_dist*VELOCITY_RANGE; } } } if ( time_step < PUSH_DECAY_TIME_CONSTANT ) { push_vector.x *= 1.0 - time_step/PUSH_DECAY_TIME_CONSTANT; push_vector.y *= 1.0 - time_step/PUSH_DECAY_TIME_CONSTANT; } else { push_vector.x = 0.0; push_vector.y = 0.0; } }