// ============================== // v.0.0.2 // Bug fix: // 1. fix Sydney's dst // 2. Handler for non-dst zones // 3. minor fixes // =============================== /** A little description of how things work. Clock face/dial .-'12'`-. ,'11 1`. /10 2\ ; : |9 3| : ; \8 4/ `.7 5,' `-._6_.-' Unit circle and the default direction of rotation. Polar coordinate is determined by a distance (radius) from the origin or any reference point and an angle from a reference direction. Each hand of a clock can be represented by a radius and an angle. 90 | .-''|'`-O ,' | r/ `. '. / | / \ '\` ; |/)a : 180 ----------+---------- 0 or 360 : | ; \ | / `. | ,' `-._|_.-' | 270 In order to convert polar coordinates by which we can represent the position of the clock's hands to Cartesian coordinates by which we can store and retrieve the estimated coordinates in a matrix, we use the following relationships to do so x = r * cos(a) y = r * sin(a) Since the above conversions work on a counter-clockwise fashion, to make it clockwise we can tweek them as x = r * sin(a) y = r * cos(a) ^ | y|___0 | /| | / | |/ | <----------+----------> | x | | | | v The process of drawing the outline of the clock's face begins with calculating the ratio of a complete revolution divided by 60. The outcome would be 6 (as 360 / 60) and that means between two consecutive minutes there is a 6° distance. So, by repeating the calculation for 60 minute-marks, we generate a full clock face. * * C * * * * * * B 1 * * * * * * * * A 2 * * * * * * * * 9 3 * * * * * * * * 8 4 * * * * * * * * 7 5 * * * * * * 6 * * To draw the clock's hands, after finding the endpoint of each hand, the DDA algorithm being used to complete the job. Drawing the minute hand is easier than the hour hand. The hour hand's position must be calculated based upon the current position of the minute hand. After calculating the initial position of the clock hand which is exactly set on a clock number, the required offset will be add to it by getting a ratio as hour hand offset = minute / 15 for example, if the time was 2:40, the 40 / 15 is 2.6 and rounding it gives us 3 (think of 3 asterisk on the clock face). Now, the hour hand must move towards hour 3. Intuitively, closing a line in q1 (see below) to x-axis, increases its x coordinate and conversely decreases its y coordinate. So, to make it even, we simply add 3 to the hour hand's initial x and subtract 3 from initial y value. \ .-'12'`-. / ,\11 1/. /10`. ,' 2\ ; \ q4/ : |9 q3 :-: q1 3| : /q2 \ ; \8 ,' `. 4/ `/7 5\' / `-._6_.-' \ */ #define _USE_MATH_DEFINES #include #include #include #include #include #include #include #include using namespace std; #define R(n) static_cast(n < 0 ? n - 0.5 : n + 0.5) //....................... //..+-----------------+.. //..| Constants |.. //..+-----------------+.. //....................... // // Size: size of a square matrix which affect on the size of hands, as well. To change the clock size, just change this value to another odd number — preferably greater than 30. // // MinRad: The radius of the minute hand. // HourRad: The radius of the hour hand. // FaceRad: The radius of the clock face. // // hourMarks[]: A lookup table to hold hour numbers. A, B, and C are represent hours 10, 11 , and 12, respectively. // // FullPrd: Indicates one revolution (60 minutes or 12 hours or 360°) on clock face // // ToDeg: A constant ratio to multiply by trig functions' arguments to give the result in degree instead of radian by default. // // MinDeg: Each minute is 6° on the polar coordinate system. This constant must be multiplied by the actual minute to calculate the correct angle of the hand. // // HourDeg: Each hour is 30° (five minute-marks on the clock face) on the polar coordinate system. This constatnt must be multiplied by the actual hour. // // HourDiv: A constant denumerator that specifies the exact offset of the hour hand based upon the current value of the minute (every 15 minutes or so the hour hand moves one minute-mark forward) as // offset = min / HourDiv // class Constants { public: // Constants related to clock's shape static constexpr int Size = 41; // Must be odd static constexpr int MinRad = Size / 3 + 1; static constexpr int HourRad = MinRad - 4; static constexpr int FaceRad = MinRad + 3; static const char hourMarks[]; // Conversion constants static constexpr double FullPrd = 360.0; static constexpr double ToDeg = M_PI / 180.0; static constexpr int MinDeg = 6; static constexpr int HourDeg = MinDeg * 5; static constexpr double HourDiv = 15.0; // Time, timezone, and calendrical constants static constexpr time_t SecInHour = 3600; static constexpr time_t SecInHalf = SecInHour / 2; static constexpr int Noon = 12; static constexpr int Year2018 = 2018; static const string strMonth[]; static const string strWday[]; static const string cityInfo[]; static const time_t utcOffsets[]; // Other constants static constexpr int NotSet = -1; static constexpr time_t NoOffset = 0; static constexpr int W = 2; }; const char Constants::hourMarks[] = { '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', '1', '2' }; const string Constants::strMonth[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; const string Constants::strWday[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; const string Constants::cityInfo[] = { "(UTC-08:00) Los Angeles", "(UTC-06:00) Mexico City", "(UTC-05:00) New York", "(UTC) London, Lisbon", "(UTC+01:00) Paris, Berlin, Madrid", "(UTC+03:00) Moscow", "(UTC+05:30) New Delhi", "(UTC+08:00) Beijing", "(UTC+09:00) Tokyo", "(UTC+10:00) Sydney" }; const time_t Constants::utcOffsets[] = { SecInHour * (-8), SecInHour * (-6), SecInHour * (-5), SecInHour * 0, SecInHour * 1, SecInHour * 3, SecInHour * 5 + SecInHalf, SecInHour * 8, SecInHour * 9, SecInHour * 10, }; //....................... //..+-----------------+.. //..| Tm |.. //..+-----------------+.. //....................... // // getZoneInfo(): Prepares and stores all information for 10 handpicked time zones. It retrieves some predefined values and calls a date and time calculator function through a loop. It returns a formmated string. // // getGmtHour(); Works hand in hand with getGmtMin() to return Greenwich Mean Time, independently. It returns an integer which gets used for constructing the analog clock. // // getLocalHour(): Same as getGmtHour(), this function and getLocalMin work together to return the system's local time, if be presented (usually, online compilers won't allow access to system time). // // getUtcDateTime(offset, zone): Responsible for calculating the current date and time for different zones. It gets an offset as the argument for each zone which then gets added to the current encoded calendar time since the Epoch. Then, a query is made from a local DB to see whether the current zone has a daylight saving time or not. Finally, all gathered information are converted to a single string and gets returned. // class Tm { public: static string getZonesInfo(); static int getGmtHour(); static int getGmtMin(); static int getLocalHour(); static int getLocalMin(); private: enum UTC { UTC_m08, UTC_m06, UTC_m05, UTC_00, // GMT UTC_p01, UTC_p03, UTC_p05_30, UTC_p08, UTC_p09, UTC_p10 }; enum Month { Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec }; static const map month; static string getUtcDateTime(time_t offset, UTC zone); static void getLocalTime(); static bool isDST(Month m, int day, UTC zone); static int gmtHour, gmtMin, localHour, localMin; }; string Tm::getZonesInfo() { string fullInfo = ""; for (int uti = UTC::UTC_m08; uti <= UTC_p10; ++uti) { fullInfo += Constants::cityInfo[uti] + "\n" + getUtcDateTime(Constants::utcOffsets[uti], static_cast(uti)) + "\n\n"; } return fullInfo; } int Tm::getGmtHour() { if (gmtHour == Constants::NotSet) getUtcDateTime(Constants::NoOffset, UTC_00); return gmtHour; } int Tm::getGmtMin() { if (gmtMin == Constants::NotSet) getUtcDateTime(Constants::NoOffset, UTC_00); return gmtMin; } int Tm::getLocalHour() { if (localHour == Constants::NotSet) getLocalTime(); return localHour; } int Tm::getLocalMin() { if (localMin == Constants::NotSet) getLocalTime(); return localMin; } string Tm::getUtcDateTime(time_t offset, UTC zone) { time_t rawT = time(nullptr) + offset; struct tm *now = gmtime(&rawT); // Save GMT hour and min for analog clock if (zone == UTC_00) { gmtHour = now->tm_hour; gmtMin = now->tm_min; } bool isSummerTime = isDST(month.find(now->tm_mon)->second, now->tm_mday, zone); if (isSummerTime) { rawT += Constants::SecInHour; now = gmtime(&rawT); } // Store required data to convert to string string wday = Constants::strWday[now->tm_wday], mon = Constants::strMonth[now->tm_mon]; int mday = now->tm_mday, year = now->tm_year + 1900; if (year > Constants::Year2018) cout << "DST might be invalid. Please update dstBase.\n"; int hour = now->tm_hour, min = now->tm_min, sec = now->tm_sec; // Build a string of all information stringstream sBuilder; sBuilder << "[" << wday << " - " << mon << " " << setw(Constants::W) << mday << ", " << year << " - " << setw(Constants::W) << hour << ":" << setw(Constants::W) << min << ":" << setw(Constants::W) << sec << "]" << (isSummerTime ? "[DST]" : ""); string info = sBuilder.str(); return info; } void Tm::getLocalTime() { time_t rawT = time(nullptr); struct tm *loc = localtime(&rawT); localHour = loc->tm_hour; localMin = loc->tm_min; } bool Tm::isDST(Month m, int day, UTC zone) { bool dst = false; if (zone > UTC_p01 && zone < UTC_p10) return dst; // Early handling non-dst zones -- bug fixed typedef map, pair>> dstBase; dstBase _2018 { // { zone, { {start date}, {end date} } } { UTC_m08, { {Mar, 11}, {Nov, 4} } }, { UTC_m06, { {Apr, 1}, {Oct, 28} } }, { UTC_m05, { {Mar, 11}, {Nov, 4} } }, { UTC_00, { {Mar, 25}, {Oct, 28} } }, { UTC_p01, { {Mar, 25}, {Oct, 28} } }, { UTC_p10, { {Oct, 7}, {Apr, 1} } }, }; auto record = _2018.find(zone); Month startm = record->second.first.first, endm = record->second.second.first; int startd = record->second.first.second, endd = record->second.second.second; // Since Sydney's DST is irregular and splits between 2 years, calculating its opposite (not dst) is much easier -- bug fixed if (record->first == UTC_p10) { if (m < startm || (m == startm && day < startd)) if (m > endm || (m == endm && day > endd)) dst = false; dst = true; } else { if (m > startm || (m == startm && day >= startd)) if (m < endm || (m == endm && day <= endd)) dst = true; dst = false; } return dst; } const map Tm::month { {0, Jan}, {1, Feb}, {2, Mar}, {3, Apr}, {4, May}, {5, Jun}, {6, Jul}, {7, Aug}, {8, Sep}, {9, Oct}, {10, Nov}, {11, Dec} }; int Tm::gmtHour = Constants::NotSet; int Tm::gmtMin = Constants::NotSet; int Tm::localHour = Constants::NotSet; int Tm::localMin = Constants::NotSet; //....................... //..+-----------------+.. //..| AnalogC |.. //..+-----------------+.. //....................... // // AnalogC(hour, minute): Provides a simple interface for constructing several analog clocks by feeding only hour and minute values. It can be used independently from the Tm class by manually passing arbitrary values or as a consistent unit with it. // // initClock(): As the name of the function suggests, it fills the clock matrix, which is acts as a Cartesian coordinate system, with space character. It also specifies the clock's center mark, clock's frame, and being AM or PM. // // setFace(): Simply set a circle by converting the radius and angle to x and y coordinates, then applying them to proper position in the matrix. // // SetHands(): The bulk of this function comprises modified DDA line algorithm. By modified, I mean the two switch blocks which modify the endpoint of the hour hand to place it in the correct position as briefly stated at the beginning. // // drawClock(): traverse the matrix and print it out. // class AnalogC { public: AnalogC(int h, int m); private: void initClock(); void setFace(); void setHands(); void drawClock(); char clock[Constants::Size][Constants::Size]; int hour, min, center; bool isPM; }; AnalogC::AnalogC(int h, int m) { if (h >= Constants::Noon) { isPM = true; if (h > Constants::Noon) hour = h - Constants::Noon; else hour = h; } else { hour = h; isPM = false; } min = m; initClock(); setFace(); setHands(); drawClock(); } void AnalogC::initClock() { // initialize the clock's background center = Constants::Size / 2; for (int i = 0; i < Constants::Size; ++i) for (int j = 0; j < Constants::Size; ++j) { if (i == center && j == center) clock[i][j] = 'O'; else if (i == center && j == (center + center / 2)) { char ap = 'A'; if (isPM) ap = 'P'; clock[i][j++] = '['; clock[i][j++] = ap; clock[i][j++] = 'M'; clock[i][j] = ']'; } else if ( (i == 0 || i == Constants::Size-1) || (j == 0 || j == Constants::Size-1) ) clock[i][j] = 'X'; else clock[i][j] = ' '; } } void AnalogC::setFace() { double x = 0, y = 0; int r = Constants::FaceRad, c = 0; for (double i = 0.0; i < Constants::FullPrd; i += Constants::MinDeg) { // adjusted to work in clock-wise fashion x = r * sin(i * Constants::ToDeg); y = r * cos(i * Constants::ToDeg); // every 30° put a clock number on the perimeter of the face if (!(static_cast(i) % Constants::HourDeg)) clock[R(x) + center][R(y) + center] = Constants::hourMarks[c++]; else clock[R(x) + center][R(y) + center] = '*'; } } void AnalogC::setHands() { int rm = Constants::MinRad, rh = Constants::HourRad, // minute hand's endpoint xmEnd = R( rm * sin((min * Constants::MinDeg) * Constants::ToDeg) ), ymEnd = R( rm * cos((min * Constants::MinDeg) * Constants::ToDeg) ), // hour hand's initial endpoint xhEnd = R( rh * sin((hour * Constants::HourDeg) * Constants::ToDeg) ), yhEnd = R( rh * cos((hour * Constants::HourDeg) * Constants::ToDeg) ), // hour hand's offset based on current minute hoffset = R(min / Constants::HourDiv), msteps, hsteps; if (abs(xmEnd) > abs(ymEnd)) msteps = abs(xmEnd); else msteps = abs(ymEnd); if (abs(xhEnd) > abs(yhEnd)) { hsteps = abs(xhEnd); switch (hour) { // quadrant 1 (q1) case 2: xhEnd += hoffset; yhEnd -= hoffset; break; case 3: case 4: xhEnd -= hoffset; yhEnd -= hoffset; break; // quadrant 3 (q3) case 8: xhEnd -= hoffset; yhEnd += hoffset; break; case 9: case 10: xhEnd += hoffset; yhEnd += hoffset; break; } } else { hsteps = abs(yhEnd); switch (hour) { // quadrant 4 (q4) case 11: case 12: case 0: // Damn! Midnight case 1: if (hour == 1 && min >= 30) yhEnd -= hoffset; xhEnd += hoffset; break; // quadrant 2 (q2) case 5: case 6: case 7: if (hour == 7 && min >= 30) yhEnd += hoffset; xhEnd -= hoffset; break; } } double xmInc = xmEnd / static_cast(msteps), ymInc = ymEnd / static_cast(msteps), xhInc = xhEnd / static_cast(hsteps), yhInc = yhEnd / static_cast(hsteps), xmNxt, ymNxt, xhNxt, yhNxt; xmNxt = ymNxt = xhNxt = yhNxt = center; // set minute hand for (int i = 0; i < msteps; ++i) { ymNxt += xmInc; xmNxt -= ymInc; // y-axis must be reversed since index increas from top to down unlike real cartesian system clock[R(xmNxt)][R(ymNxt)] = 'M'; } // set hour hand for (int i = 0; i < hsteps; ++i) { yhNxt += xhInc; xhNxt -= yhInc; clock[R(xhNxt)][R(yhNxt)] = 'H'; } } void AnalogC::drawClock() { for (int i = 0; i < Constants::Size; ++i) { for (int j = 0; j < Constants::Size; ++j) cout << clock[i][j]; cout << endl; } } //....................... //..+-----------------+.. //..| Main |.. //..+-----------------+.. //....................... int main() { cout << " *** Greenwich Mean Time ***\n"; AnalogC clk1(Tm::getGmtHour(), Tm::getGmtMin()); //cout << " *** System Local Time ***\n"; //AnalogC clk2(Tm::getLocalHour(), Tm::getLocalMin()); cout << "\n ** Time & Date all around the world **\n\n"; cout << Tm::getZonesInfo() << endl; }

World Clock v.0.0.2