위도 및 경도 좌표를 사용하여 위치에서 시간대를 얻는 방법은 무엇입니까?

위치에서 시간대를 해결하는 방법에 대한 StackOverflow에 대한 질문이 너무 많습니다. 이 커뮤니티 위키는 유효한 모든 응답을 통합하려는 시도입니다.

내 답변을 업데이트하거나 적절하다고 생각되면 직접 추가하십시오.

질문
위치의 위도와 경도를 고려할 때 해당 위치에서 어떤 시간대가 유효한지 어떻게 알 수 있습니까?

일부 서비스는 UTC 오프셋 또는 다른 시간대 식별자 만 반환 할 수 있지만 대부분의 경우 IANA / Olson 시간대 ID를 찾고 있습니다. 자세한 내용은 시간대 태그 정보 를 읽으십시오 .

시간대 위치 웹 서비스

• Google Maps 시간대 API
• 빙지도 시간대 API
• Azure Maps 표준 시간대 API
• GeoNames 시간대 API
• TimeZoneDB API
• AskGeo- 상업용 (하지만 GeoNames보다 정확함 )
• GeoGarage 시간대 API- 상용, 해상 시간대에 중점을 둡니다.

원시 시간대 경계 데이터

• 시간대 경계 빌더 -OpenStreetMaps 맵 데이터에서 시간대 모양 파일을 빌드합니다. 해안선 근처에 영해가 포함되어 있습니다.

다음 프로젝트는 이전에 시간대 경계 데이터의 소스 였지만 더 이상 적극적으로 유지 관리되지 않습니다.

• tz_world -Eric Muller의 원본 shapefile 데이터
• where-timezone- WOEDB 데이터가 병합 된 GeoJSON 버전

시간대 지리적 위치 오프라인 구현

시간대 경계 빌더 데이터를 사용하는 구현

• node-geo-tz -JavaScript 라이브러리 (Node.js 전용)
• 타임 스페이스-JavaScript 라이브러리
• tz-lookup -JavaScript 라이브러리
• GeoTimeZone-.NET 라이브러리
• 지역 시간대 -PHP 라이브러리
• 시간대 측정기 -Python 라이브러리
• ZoneDetect -C 라이브러리
• 타임 셰이프-Java 라이브러리
• TimeZoneMap -Java 및 Android 라이브러리
• lutz -R 라이브러리
• go-tz- 도서관 이동
• 시간대 조회 -라이브러리 이동
• docker-timezone- lookup-도커 컨테이너 래핑 노드 -geo-tz

더 오래된 tz_world 데이터를 사용하는 구현

• latlong -Go library ( 이 게시물 도 읽으십시오 .)
• TimeZoneMapper- 자바 라이브러리
• tzwhere -JavaScript / 노드 라이브러리
• pytzwhere- 파이썬 라이브러리
• timezone_finder- 루비 라이브러리
• LatLongToTimeZone -Java 및 Swift 라이브러리
• 몇시입니까? -PHP 및 MongoDB를 설명하는 블로그 게시물
• 런델 / 시간대 -R 라이브러리

웹 서비스 중 하나를 호출하는 라이브러리

• 시간대 -GeoName을 호출하는 Ruby gem
• AskGeo 에는 Java 또는 .Net에서 호출하기위한 자체 라이브러리가 있습니다.
• GeoNames 에는 거의 모든 것을위한 클라이언트 라이브러리가 있습니다

자체 호스팅 웹 서비스

• geo2tz 기반 시간대 검색 ( Docker 이미지를 통해 사용 가능)

다른 아이디어

• R- 트리가있는 가장 가까운 도시 를 찾으십시오
• MySQL로 가장 가까운 도시 를 찾으십시오

다른 사람이 있으면이 목록을 업데이트하십시오

또한 가장 가까운 도시 접근 방식은 "정확한"결과가 아닌 근사치 일 수 있습니다.

Windows 영역으로 변환

나열된 대부분의 메소드는 IANA 시간대 ID를 리턴합니다. TimeZoneInfo.NET 의 클래스 와 함께 사용하기 위해 Windows 표준 시간대로 변환해야하는 경우 TimeZoneConverter 라이브러리를 사용하십시오 .

zone.tab을 사용하지 마십시오

TZ 데이터베이스 라는 파일이 포함되어 있습니다 zone.tab. 이 파일은 주로 사용자가 선택할 수있는 시간대 목록을 제공하는 데 사용됩니다. 각 시간대의 기준점에 대한 위도 및 경도 좌표를 포함합니다. 이를 통해 이러한 지점을 강조 표시하는지도를 만들 수 있습니다. 예를 들어, 순간 시간대 홈 페이지 에 표시된 대화식 맵을 참조하십시오 .

위도 및 경도 좌표에서 시간대를 해결하기 위해이 데이터를 사용하고 싶은 유혹이있을 수 있지만, 이것이 경계가 아닌 점임을 고려하십시오. 가장 좋은 방법은 가장 가까운 점 을 결정하는 것입니다. 대부분의 경우 올바른 점이 아닙니다.

다음 예제를 고려하십시오.

두 사각형은 서로 다른 시간대를 나타내며 각 사각형의 검은 점은 zone.tab에서 찾을 수있는 것과 같은 참조 위치입니다. 파란색 점은 시간대를 찾으려고하는 위치를 나타냅니다. 분명히이 위치는 왼쪽의 주황색 영역 내에 있지만 기준점과 가장 가까운 거리를 보면 오른쪽의 녹색 영역으로 해석됩니다.

node.js에 대한이 솔루션은 어떻습니까? https://github.com/mattbornski/tzwhere

그리고 파이썬의 대응 자 : https://github.com/pegler/pytzwhere

우리 텔레포트가 막 시작 우리의 API의 개방 과 쓰임새 중 하나는 좌표 TZ 정보를 노출됩니다.

예를 들어 다음과 같은 방법으로 좌표에 대한 사용 가능한 모든 TZ 정보를 요청할 수 있습니다.

curl -s https://api.teleport.org/api/locations/59.4372,24.7453/?embed=location:nearest-cities/location:nearest-city/city:timezone/tz:offsets-now | jq '._embedded."location:nearest-cities"[0]._embedded."location:nearest-city"._embedded."city:timezone"'

이것은 다음을 반환합니다

{
  "_embedded": {
    "tz:offsets-now": {
      "_links": {
        "self": {
          "href": "https://api.teleport.org/api/timezones/iana:Europe%2FTallinn/offsets/?date=2015-09-07T11%3A20%3A09Z"
        }
      },
      "base_offset_min": 120,
      "dst_offset_min": 60,
      "end_time": "2015-10-25T01:00:00Z",
      "short_name": "EEST",
      "total_offset_min": 180,
      "transition_time": "2015-03-29T01:00:00Z"
    }
  },
  "_links": {
    "self": {
      "href": "https://api.teleport.org/api/timezones/iana:Europe%2FTallinn/"
    },
    "tz:offsets": {
      "href": "https://api.teleport.org/api/timezones/iana:Europe%2FTallinn/offsets/{?date}",
      "templated": true
    },
    "tz:offsets-now": {
      "href": "https://api.teleport.org/api/timezones/iana:Europe%2FTallinn/offsets/?date=2015-09-07T11%3A20%3A09Z"
    }
  },
  "iana_name": "Europe/Tallinn"
}

예를 들어 JSON 구문 분석에 ./jq 를 사용 했습니다 .

다음은 Google의 스크립트 편집기를 사용하여 gsheet 내에서 timezoneName 및 timeZoneId를 얻는 방법입니다.

1 단계. Google 시간대 API 용 API 키 가져 오기

2 단계. 새 gsheet를 만듭니다. '도구'메뉴 아래에서 '스크립트 편집기'를 클릭하십시오. 다음 코드를 추가하십시오 :

function getTimezone(lat, long) {  
  var apiKey = 'INSERTAPIKEYHERE'
  var url = 'https://maps.googleapis.com/maps/api/timezone/json?location=' + lat + ',' + long + '&timestamp=1331161200&key=' + apiKey 
  var response = UrlFetchApp.fetch(url);
  var data = JSON.parse(response.getContentText());
  return data["timeZoneName"];
}

3 단계. getTimezone()함수를 저장 및 게시 하고 위 이미지와 같이 사용하십시오.

geolocator.js 를 사용할 수 있습니다시간대 등을 쉽게 얻기 를 ...

키가 필요한 Google API를 사용합니다. 따라서 먼저 geolocator를 구성하십시오.

geolocator.config({
    language: "en",
    google: {
        version: "3",
        key: "YOUR-GOOGLE-API-KEY"
    }
});

좌표가있는 경우 TimeZone을 가져옵니다.

geolocator.getTimeZone(options, function (err, timezone) {
    console.log(err || timezone);
});

출력 예 :

{
    id: "Europe/Paris",
    name: "Central European Standard Time",
    abbr: "CEST",
    dstOffset: 0,
    rawOffset: 3600,
    timestamp: 1455733120
}

TimeZone 등을 찾아서 가져옵니다.

좌표가 없으면 먼저 사용자 위치를 찾을 수 있습니다.

아래 예제는 먼저 좌표를 얻기 위해 HTML5 Geolocation API를 시도합니다. 실패하거나 거부하면 Geo-IP 조회를 통해 좌표를 얻습니다. 마지막으로 시간대와 더 많은 것을 얻을 것입니다 ...

var options = {
    enableHighAccuracy: true,
    timeout: 6000,
    maximumAge: 0,
    desiredAccuracy: 30,
    fallbackToIP: true, // if HTML5 fails or rejected
    addressLookup: true, // this will get full address information
    timezone: true,
    map: "my-map" // this will even create a map for you
};
geolocator.locate(options, function (err, location) {
    console.log(err || location);
});

출력 예 :

{
    coords: {
        latitude: 37.4224764,
        longitude: -122.0842499,
        accuracy: 30,
        altitude: null,
        altitudeAccuracy: null,
        heading: null,
        speed: null
    },
    address: {
        commonName: "",
        street: "Amphitheatre Pkwy",
        route: "Amphitheatre Pkwy",
        streetNumber: "1600",
        neighborhood: "",
        town: "",
        city: "Mountain View",
        region: "Santa Clara County",
        state: "California",
        stateCode: "CA",
        postalCode: "94043",
        country: "United States",
        countryCode: "US"
    },
    formattedAddress: "1600 Amphitheatre Parkway, Mountain View, CA 94043, USA",
    type: "ROOFTOP",
    placeId: "ChIJ2eUgeAK6j4ARbn5u_wAGqWA",
    timezone: {
        id: "America/Los_Angeles",
        name: "Pacific Standard Time",
        abbr: "PST",
        dstOffset: 0,
        rawOffset: -28800
    },
    flag: "//cdnjs.cloudflare.com/ajax/libs/flag-icon-css/2.3.1/flags/4x3/us.svg",
    map: {
        element: HTMLElement,
        instance: Object, // google.maps.Map
        marker: Object, // google.maps.Marker
        infoWindow: Object, // google.maps.InfoWindow
        options: Object // map options
    },
    timestamp: 1456795956380
}

https://en.wikipedia.org/wiki/Great-circle_distance

다음은 JSON 데이터를 사용하는 좋은 구현입니다. https://github.com/agap/llttz

public TimeZone nearestTimeZone(Location node) {
    double bestDistance = Double.MAX_VALUE;
    Location bestGuess = timeZones.get(0);

    for (Location current : timeZones.subList(1, timeZones.size())) {
        double newDistance = distanceInKilometers(node, current);

        if (newDistance < bestDistance) {
            bestDistance = newDistance;
            bestGuess = current;
        }
    }

    return java.util.TimeZone.getTimeZone(bestGuess.getZone());
}

  protected double distanceInKilometers(final double latFrom, final double lonFrom, final double latTo, final double lonTo) {
        final double meridianLength = 111.1;
        return meridianLength * centralAngle(latFrom, lonFrom, latTo, lonTo);
    }

    protected double centralAngle(final Location from, final Location to) {
        return centralAngle(from.getLatitude(), from.getLongitude(), to.getLatitude(), to.getLongitude());
    }

    protected double centralAngle(final double latFrom, final double lonFrom, final double latTo, final double lonTo) {
        final double latFromRad = toRadians(latFrom),
                lonFromRad = toRadians(lonFrom),
                latToRad   = toRadians(latTo),
                lonToRad   = toRadians(lonTo);

        final double centralAngle = toDegrees(acos(sin(latFromRad) * sin(latToRad) + cos(latFromRad) * cos(latToRad) * cos(lonToRad - lonFromRad)));

        return centralAngle <= 180.0 ? centralAngle : (360.0 - centralAngle);
    }

    protected double distanceInKilometers(final Location from, final Location to) {
        return distanceInKilometers(from.getLatitude(), from.getLongitude(), to.getLatitude(), to.getLongitude());
    }
}

공개 : 나는 아래에 설명 된 도커 이미지의 저자입니다.

나는 아주 간단한 도커 컨테이너에 https://github.com/evansiroky/node-geo-tz 를 감쌌다.

https://hub.docker.com/repository/docker/tobias74/timezone-lookup

도커 컨테이너를 시작할 수 있습니다

docker run -p 80:3000 tobias74/timezone-lookup:latest

그러면 포트 3000의 로컬 호스트에서 조회 서비스가 표시됩니다. 그런 다음 시간대 검색을 수행 할 수 있습니다.

curl "localhost:3000/timezone?latitude=12&longitude=34"

현재 NTP 시간 클라이언트에서 Java의 Google 시간대 API를 사용하고 올바른 UTC_Datetime_from_timestamp 변환을 사용하려면이 코드를 사용하십시오.

String get_xml_server_reponse(String server_url){

    URL xml_server = null;

    String xmltext = "";

    InputStream input;


    try {
        xml_server = new URL(server_url);


        try {
            input = xml_server.openConnection().getInputStream();


            final BufferedReader reader = new BufferedReader(new InputStreamReader(input));
            final StringBuilder sBuf = new StringBuilder();

            String line = null;
            try {
                while ((line = reader.readLine()) != null) 
                {
                    sBuf.append(line);
                }
               } 
            catch (IOException e) 
              {
                    Log.e(e.getMessage(), "XML parser, stream2string 1");
              } 
            finally {
                try {
                    input.close();
                    }
                catch (IOException e) 
                {
                    Log.e(e.getMessage(), "XML parser, stream2string 2");
                }
            }

            xmltext =  sBuf.toString();

        } catch (IOException e1) {

                e1.printStackTrace();
            }


        } catch (MalformedURLException e1) {

          e1.printStackTrace();
        }

     return  xmltext;

  }     


 private String get_UTC_Datetime_from_timestamp(long timeStamp){

    try{

        Calendar cal = Calendar.getInstance();
        TimeZone tz = cal.getTimeZone();

        int tzt = tz.getOffset(System.currentTimeMillis());

        timeStamp -= tzt;

        // DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",Locale.getDefault());
        DateFormat sdf = new SimpleDateFormat();
        Date netDate = (new Date(timeStamp));
        return sdf.format(netDate);
    }
    catch(Exception ex){
        return "";
     }
    } 

 class NTP_UTC_Time
 {
     private static final String TAG = "SntpClient";

     private static final int RECEIVE_TIME_OFFSET = 32;
     private static final int TRANSMIT_TIME_OFFSET = 40;
     private static final int NTP_PACKET_SIZE = 48;

     private static final int NTP_PORT = 123;
     private static final int NTP_MODE_CLIENT = 3;
     private static final int NTP_VERSION = 3;

     // Number of seconds between Jan 1, 1900 and Jan 1, 1970
     // 70 years plus 17 leap days
     private static final long OFFSET_1900_TO_1970 = ((365L * 70L) + 17L) * 24L * 60L * 60L;

     private long mNtpTime;

     public boolean requestTime(String host, int timeout) {
         try {
             DatagramSocket socket = new DatagramSocket();
             socket.setSoTimeout(timeout);
             InetAddress address = InetAddress.getByName(host);
             byte[] buffer = new byte[NTP_PACKET_SIZE];
             DatagramPacket request = new DatagramPacket(buffer, buffer.length, address, NTP_PORT);

             buffer[0] = NTP_MODE_CLIENT | (NTP_VERSION << 3);

             writeTimeStamp(buffer, TRANSMIT_TIME_OFFSET);

             socket.send(request);

             // read the response
             DatagramPacket response = new DatagramPacket(buffer, buffer.length);
             socket.receive(response);          
             socket.close();

             mNtpTime = readTimeStamp(buffer, RECEIVE_TIME_OFFSET);            
         } catch (Exception e) {
           //  if (Config.LOGD) Log.d(TAG, "request time failed: " + e);
             return false;
         }

         return true;
     }


     public long getNtpTime() {
         return mNtpTime;
     }


     /**
      * Reads an unsigned 32 bit big endian number from the given offset in the buffer.
      */
     private long read32(byte[] buffer, int offset) {
         byte b0 = buffer[offset];
         byte b1 = buffer[offset+1];
         byte b2 = buffer[offset+2];
         byte b3 = buffer[offset+3];

         // convert signed bytes to unsigned values
         int i0 = ((b0 & 0x80) == 0x80 ? (b0 & 0x7F) + 0x80 : b0);
         int i1 = ((b1 & 0x80) == 0x80 ? (b1 & 0x7F) + 0x80 : b1);
         int i2 = ((b2 & 0x80) == 0x80 ? (b2 & 0x7F) + 0x80 : b2);
         int i3 = ((b3 & 0x80) == 0x80 ? (b3 & 0x7F) + 0x80 : b3);

         return ((long)i0 << 24) + ((long)i1 << 16) + ((long)i2 << 8) + (long)i3;
     }

     /**
      * Reads the NTP time stamp at the given offset in the buffer and returns 
      * it as a system time (milliseconds since January 1, 1970).
      */    
     private long readTimeStamp(byte[] buffer, int offset) {
         long seconds = read32(buffer, offset);
         long fraction = read32(buffer, offset + 4);
         return ((seconds - OFFSET_1900_TO_1970) * 1000) + ((fraction * 1000L) / 0x100000000L);        
     }

     /**
      * Writes 0 as NTP starttime stamp in the buffer. --> Then NTP returns Time OFFSET since 1900
      */    
     private void writeTimeStamp(byte[] buffer, int offset) {        
         int ofs =  offset++;

         for (int i=ofs;i<(ofs+8);i++)
           buffer[i] = (byte)(0);             
     }

 }

 String get_time_zone_time(GeoPoint gp){

        String erg = "";
        String raw_offset = "";
        String dst_offset = "";

        double Longitude = gp.getLongitudeE6()/1E6;
        double Latitude = gp.getLatitudeE6()/1E6;



        long tsLong = 0; // System.currentTimeMillis()/1000;

        NTP_UTC_Time client = new NTP_UTC_Time();

        if (client.requestTime("pool.ntp.org", 2000)) {              
          tsLong = client.getNtpTime();
        }

        if (tsLong != 0)
        {

        tsLong = tsLong  / 1000;

        // https://maps.googleapis.com/maps/api/timezone/xml?location=39.6034810,-119.6822510&timestamp=1331161200&sensor=false

        String request = "https://maps.googleapis.com/maps/api/timezone/xml?location="+Latitude+","+ Longitude+ "&timestamp="+tsLong +"&sensor=false";

        String xmltext = get_xml_server_reponse(request);

        if(xmltext.compareTo("")!= 0)
        {

         int startpos = xmltext.indexOf("<TimeZoneResponse");
         xmltext = xmltext.substring(startpos);



        XmlPullParser parser;
        try {
            parser = XmlPullParserFactory.newInstance().newPullParser();


             parser.setInput(new StringReader (xmltext));

             int eventType = parser.getEventType();  

             String tagName = "";


             while(eventType != XmlPullParser.END_DOCUMENT) {
                 switch(eventType) {

                     case XmlPullParser.START_TAG:

                           tagName = parser.getName();

                         break;


                     case XmlPullParser.TEXT :


                        if  (tagName.equalsIgnoreCase("raw_offset"))
                          if(raw_offset.compareTo("")== 0)                               
                            raw_offset = parser.getText();  

                        if  (tagName.equalsIgnoreCase("dst_offset"))
                          if(dst_offset.compareTo("")== 0)
                            dst_offset = parser.getText();  


                        break;   

                 }

                 try {
                        eventType = parser.next();
                    } catch (IOException e) {

                        e.printStackTrace();
                    }

                }

                } catch (XmlPullParserException e) {

                    e.printStackTrace();
                    erg += e.toString();
                }

        }      

        int ro = 0;
        if(raw_offset.compareTo("")!= 0)
        { 
            float rof = str_to_float(raw_offset);
            ro = (int)rof;
        }

        int dof = 0;
        if(dst_offset.compareTo("")!= 0)
        { 
            float doff = str_to_float(dst_offset);
            dof = (int)doff;
        }

        tsLong = (tsLong + ro + dof) * 1000;



        erg = get_UTC_Datetime_from_timestamp(tsLong);
        }


  return erg;

}

그리고 그것을 다음과 함께 사용하십시오 :

GeoPoint gp = new GeoPoint(39.6034810,-119.6822510);
String Current_TimeZone_Time = get_time_zone_time(gp);

여기에 올바른 NTP 시간이없는 짧은 버전이 있습니다.

String get_xml_server_reponse(String server_url){

URL xml_server = null;

String xmltext = "";

InputStream input;


try {
    xml_server = new URL(server_url);


    try {
        input = xml_server.openConnection().getInputStream();


        final BufferedReader reader = new BufferedReader(new InputStreamReader(input));
        final StringBuilder sBuf = new StringBuilder();

        String line = null;
        try {
            while ((line = reader.readLine()) != null) 
            {
                sBuf.append(line);
            }
           } 
        catch (IOException e) 
          {
                Log.e(e.getMessage(), "XML parser, stream2string 1");
          } 
        finally {
            try {
                input.close();
                }
            catch (IOException e) 
            {
                Log.e(e.getMessage(), "XML parser, stream2string 2");
            }
        }

        xmltext =  sBuf.toString();

    } catch (IOException e1) {

            e1.printStackTrace();
        }


    } catch (MalformedURLException e1) {

      e1.printStackTrace();
    }

 return  xmltext;

} 


long get_time_zone_time_l(GeoPoint gp){


        String raw_offset = "";
        String dst_offset = "";

        double Longitude = gp.getLongitudeE6()/1E6;
        double Latitude = gp.getLatitudeE6()/1E6;

        long tsLong = System.currentTimeMillis()/1000;


        if (tsLong != 0)
        {

        // https://maps.googleapis.com/maps/api/timezone/xml?location=39.6034810,-119.6822510&timestamp=1331161200&sensor=false

        String request = "https://maps.googleapis.com/maps/api/timezone/xml?location="+Latitude+","+ Longitude+ "&timestamp="+tsLong +"&sensor=false";

        String xmltext = get_xml_server_reponse(request);

        if(xmltext.compareTo("")!= 0)
        {

         int startpos = xmltext.indexOf("<TimeZoneResponse");
         xmltext = xmltext.substring(startpos);



        XmlPullParser parser;
        try {
            parser = XmlPullParserFactory.newInstance().newPullParser();


             parser.setInput(new StringReader (xmltext));

             int eventType = parser.getEventType();  

             String tagName = "";


             while(eventType != XmlPullParser.END_DOCUMENT) {
                 switch(eventType) {

                     case XmlPullParser.START_TAG:

                           tagName = parser.getName();

                         break;


                     case XmlPullParser.TEXT :


                        if  (tagName.equalsIgnoreCase("raw_offset"))
                          if(raw_offset.compareTo("")== 0)                               
                            raw_offset = parser.getText();  

                        if  (tagName.equalsIgnoreCase("dst_offset"))
                          if(dst_offset.compareTo("")== 0)
                            dst_offset = parser.getText();  


                        break;   

                 }

                 try {
                        eventType = parser.next();
                    } catch (IOException e) {

                        e.printStackTrace();
                    }

                }

                } catch (XmlPullParserException e) {

                    e.printStackTrace();
                    erg += e.toString();
                }

        }      

        int ro = 0;
        if(raw_offset.compareTo("")!= 0)
        { 
            float rof = str_to_float(raw_offset);
            ro = (int)rof;
        }

        int dof = 0;
        if(dst_offset.compareTo("")!= 0)
        { 
            float doff = str_to_float(dst_offset);
            dof = (int)doff;
        }

        tsLong = (tsLong + ro + dof) * 1000;


        }


  return tsLong;

}

그리고 그것을 다음과 함께 사용하십시오 :

GeoPoint gp = new GeoPoint(39.6034810,-119.6822510);
long Current_TimeZone_Time_l = get_time_zone_time_l(gp);

geonames.org를 사용하려면이 코드를 사용하십시오. (그러나 geonames.org는 때때로 매우 느립니다)

String get_time_zone_time_geonames(GeoPoint gp){


        String erg = "";

        double Longitude = gp.getLongitudeE6()/1E6;
        double Latitude = gp.getLatitudeE6()/1E6;



        String request = "http://ws.geonames.org/timezone?lat="+Latitude+"&lng="+ Longitude+ "&style=full";

        URL time_zone_time = null;

        InputStream input;
       // final StringBuilder sBuf = new StringBuilder();


        try {
            time_zone_time = new URL(request);


        try {
            input = time_zone_time.openConnection().getInputStream();


        final BufferedReader reader = new BufferedReader(new InputStreamReader(input));
            final StringBuilder sBuf = new StringBuilder();

            String line = null;
            try {
                while ((line = reader.readLine()) != null) {
                    sBuf.append(line);
                }
            } catch (IOException e) {
                    Log.e(e.getMessage(), "XML parser, stream2string 1");
            } finally {
                try {
                    input.close();
                } catch (IOException e) {
                    Log.e(e.getMessage(), "XML parser, stream2string 2");
                }
            }




             String xmltext = sBuf.toString();


             int startpos = xmltext.indexOf("<geonames");
             xmltext = xmltext.substring(startpos);



            XmlPullParser parser;
            try {
                parser = XmlPullParserFactory.newInstance().newPullParser();


            parser.setInput(new StringReader (xmltext));

            int eventType = parser.getEventType();  

            String tagName = "";

            while(eventType != XmlPullParser.END_DOCUMENT) {
                switch(eventType) {

                    case XmlPullParser.START_TAG:

                          tagName = parser.getName();

                        break;


                    case XmlPullParser.TEXT :


                        if  (tagName.equalsIgnoreCase("time"))
                          erg = parser.getText();  


                    break;   

                }

                try {
                    eventType = parser.next();
                } catch (IOException e) {

                    e.printStackTrace();
                }

            }

            } catch (XmlPullParserException e) {

                e.printStackTrace();
                erg += e.toString();
            }



            } catch (IOException e1) {

                e1.printStackTrace();
            }


            } catch (MalformedURLException e1) {

                e1.printStackTrace();
            }





        return erg;

 }

그리고 그것을 다음과 함께 사용하십시오 :

GeoPoint gp = new GeoPoint(39.6034810,-119.6822510);
String Current_TimeZone_Time = get_time_zone_time_geonames(gp);

구피에서 :

import geocoders
g = geocoders.GoogleV3()
place, (lat, lng) = g.geocode('Fairbanks')
print place, (lat, lng)
Fairbanks, AK, USA (64.8377778, -147.7163889)
timezone = g.timezone((lat, lng))
print timezone.dst

바운드 방법 America/Anchorage.dst의DstTzInfo

미국 / 앵커리지의 LMT-1 일, 14:00:00 STD

이 문제가 대부분의 사람들보다 더 복잡한 문제라는 것을 인식하는 것이 중요합니다. 실제로 우리 중 많은 사람들은 최소한 가능한 한 많은 경우에 적용되는 작동 가능한 코드 세트를 기꺼이 받아들이고 있습니다. 여기서 최소한 치명적인 문제를 식별하고 최소화 할 수 있습니다. 그래서 나는 이것을 OP와 OP의 정신을 염두에두고 게시합니다. 마지막으로 위치에 민감한 시간 객체를 갖는 최종 목표로 GPS를 시간대로 변환하려는 다른 사람들에게 실용적인 가치를 제공하기 위해 (그리고 더 중요한 것은이 위키에서 따르는 시간 객체로 평균 구현의 품질을 향상시키는 데 도움이 됨) 여기 있습니다. 내가 파이썬에서 생성 한 것 (무료로 편집하십시오) :

import pytz
from datetime import datetime
from tzwhere import tzwhere

def timezoned_unixtime(latitude, longitude, dt):
    tzw = tzwhere.tzwhere()
    timezone_str = tzw.tzNameAt(latitude, longitude)
    timezone = pytz.timezone(timezone_str)
    timezone_aware_datetime = timezone.localize(dt, is_dst=None)
    unix_time = (timezone_aware_datetime - datetime(1970, 1, 1, tzinfo=pytz.utc)).total_seconds()
    return unix_time

dt = datetime(year=2017, month=1, day=17, hour=12, minute=0, second=0)
print timezoned_unixtime(latitude=40.747854, longitude=-74.004733, dt=dt)

1. 시간대에 대한 geojson 데이터가있는 여러 소스가 온라인에 있습니다 ( 여기 하나 , 여기 또 하나)

2. geojson 좌표계에서 다각형 객체를 생성하는 형상 라이브러리를 사용하여 ( 매끈한 [파이썬] GEOS [C ++, JTS [자바, NTS [.NET).

3. 위도 / 경도를 점 객체로 변환하지만 라이브러리가이를 나타내는 시간대 다각형과 교차하는지 확인하십시오.

   from shapely.geometry import Polygon, Point
   
   def get_tz_from_lat_lng(lat, lng):
       for tz, geojson in timezones.iteritems():
           coordinates = geojson['features'][0]['geometry']['coordinates']
           polygon = Polygon(coordinates)
           point = Point(lng, lat)
           if polygon.contains(point):
               return tz
   

위도 및 경도를 사용하여 코드 아래에서 현재 위치의 시간대를 가져옵니다.

String data = null;         
LocationManager locationManager = (LocationManager) getSystemService(LOCATION_SERVICE);
Location ll = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
double lat = 0,lng = 0;
if(ll!=null){
    lat=ll.getLatitude();
    lng=ll.getLongitude();
}
System.out.println(" Last known location of device  == "+lat+"    "+lng);

InputStream iStream = null; 
HttpURLConnection urlConnection = null;
try{
    timezoneurl = timezoneurl+"location=22.7260783,75.8781553&timestamp=1331161200";                    
    // timezoneurl = timezoneurl+"location="+lat+","+lng+"&timestamp=1331161200";

    URL url = new URL(timezoneurl);                
    // Creating an http connection to communicate with url 
    urlConnection = (HttpURLConnection) url.openConnection(); 

    // Connecting to url 
    urlConnection.connect();                

    // Reading data from url 
    iStream = urlConnection.getInputStream();

    BufferedReader br = new BufferedReader(new InputStreamReader(iStream));

    StringBuffer sb  = new StringBuffer();
    String line = "";
    while( ( line = br.readLine())  != null){
        sb.append(line);
    }
    data = sb.toString();
    br.close();

}catch(Exception e){
    Log.d("Exception while downloading url", e.toString());
}finally{
    try {
        iStream.close();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    urlConnection.disconnect();
}

try {
    if(data!=null){
        JSONObject jobj=new JSONObject(data);
        timezoneId = jobj.getString("timeZoneId");

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        format.setTimeZone(TimeZone.getTimeZone(timezoneId));

        Calendar cl = Calendar.getInstance(TimeZone.getTimeZone(timezoneId));
        System.out.println("time zone id in android ==  "+timezoneId);

        System.out.println("time zone of  device in android == "+TimeZone.getTimeZone(timezoneId));
        System.out.println("time fo device in android "+cl.getTime());
    }
} catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

Javascript를 사용하고 Google API를 통해 우편 번호에서 시간대를 얻으려는 사람들에게는 여기에 한 가지 방법이 있습니다.

1. 지리적 위치를 통해 위도 / 경도 가져 오기
2. 시간대 API에 시간대를 전달하여 시간대를 가져옵니다 .
   • 시간대 변환을 위해 Luxon을 사용 합니다.

참고 : 우편 번호는 국가마다 고유하지 않으므로 미국에서 사용하기에 가장 적합합니다.

const googleMapsClient; // instantiate your client here
const zipcode = '90210'
const myDateThatNeedsTZAdjustment; // define your date that needs adjusting
// fetch lat/lng from google api by zipcode
const geocodeResponse = await googleMapsClient.geocode({ address: zipcode }).asPromise();
if (geocodeResponse.json.status === 'OK') {
  lat = geocodeResponse.json.results[0].geometry.location.lat;
  lng = geocodeResponse.json.results[0].geometry.location.lng;
} else {
  console.log('Geocode was not successful for the following reason: ' + status);
}

// prepare lat/lng and timestamp of profile created_at to fetch time zone
const location = `${lat},${lng}`;
const timestamp = new Date().valueOf() / 1000;
const timezoneResponse = await googleMapsClient
  .timezone({ location: location, timestamp: timestamp })
  .asPromise();

const timeZoneId = timezoneResponse.json.timeZoneId;
// adjust by setting timezone
const timezoneAdjustedDate = DateTime.fromJSDate(
  myDateThatNeedsTZAdjustment
).setZone(timeZoneId);

웹 서비스를 피하려면 다음과 같이 브라우저에서 해당 정보를 검색하십시오.

var d = new Date();
var usertime = d.toLocaleString();

//some browsers / OSs provide the timezone name in their local string
var tzsregex = /\b(ACDT|ACST|ACT|ADT|AEDT|AEST|AFT|AKDT|AKST|AMST|AMT|ART|AST|AWDT|AWST|AZOST|AZT|BDT|BIOT|BIT|BOT|BRT|BST|BTT|CAT|CCT|CDT|CEDT|CEST|CET|CHADT|CHAST|CIST|CKT|CLST|CLT|COST|COT|CST|CT|CVT|CXT|CHST|DFT|EAST|EAT|ECT|EDT|EEDT|EEST|EET|EST|FJT|FKST|FKT|GALT|GET|GFT|GILT|GIT|GMT|GST|GYT|HADT|HAEC|HAST|HKT|HMT|HST|ICT|IDT|IRKT|IRST|IST|JST|KRAT|KST|LHST|LINT|MART|MAGT|MDT|MET|MEST|MIT|MSD|MSK|MST|MUT|MYT|NDT|NFT|NPT|NST|NT|NZDT|NZST|OMST|PDT|PETT|PHOT|PKT|PST|RET|SAMT|SAST|SBT|SCT|SGT|SLT|SST|TAHT|THA|UYST|UYT|VET|VLAT|WAT|WEDT|WEST|WET|WST|YAKT|YEKT)\b/gi;

//in other browsers the timezone needs to be estimated based on the offset
var timezonenames = {"UTC+0":"GMT","UTC+1":"CET","UTC+2":"EET","UTC+3":"EEDT","UTC+3.5":"IRST","UTC+4":"MSD","UTC+4.5":"AFT","UTC+5":"PKT","UTC+5.5":"IST","UTC+6":"BST","UTC+6.5":"MST","UTC+7":"THA","UTC+8":"AWST","UTC+9":"AWDT","UTC+9.5":"ACST","UTC+10":"AEST","UTC+10.5":"ACDT","UTC+11":"AEDT","UTC+11.5":"NFT","UTC+12":"NZST","UTC-1":"AZOST","UTC-2":"GST","UTC-3":"BRT","UTC-3.5":"NST","UTC-4":"CLT","UTC-4.5":"VET","UTC-5":"EST","UTC-6":"CST","UTC-7":"MST","UTC-8":"PST","UTC-9":"AKST","UTC-9.5":"MIT","UTC-10":"HST","UTC-11":"SST","UTC-12":"BIT"};

var timezone = usertime.match(tzsregex);
if (timezone) {
    timezone = timezone[timezone.length-1];
} else {
    var offset = -1*d.getTimezoneOffset()/60;
    offset = "UTC" + (offset >= 0 ? "+" + offset : offset);
    timezone = timezonenames[offset];
}

//there are 3 variables can use to see the timezone
// usertime - full date
// offset - UTC offset time
// timezone - country

console.log('Full Date: ' + usertime);
console.log('UTC Offset: ' + offset);
console.log('Country Code Timezone: ' + timezone);

현재의 경우 인쇄 중입니다.

전체 날짜 : 27 / 01 / 2014 16 : 53 : 37 UTC 오프셋 : UTC-3 국가 코드 시간대 : BRT

도움이 되길 바랍니다.