Python KML_ElementMaker.range方法代码示例

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
 def kml_addAnimPoint(self, pos, tm):
     #pos[0] : latitude
     #pos[1] : longitude
     #pos[2] : altitude
     #pos[3] : roll
     #pos[4] : pitch
     #pos[5] : yaw
     if (pos == None):
         return
     
     localTimeStr = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.localtime(tm))
     #rospy.logerr(localTimeStr)
     self.anim_fld.append(KML.Placemark(
         KML.TimeStamp(
             KML.when(localTimeStr)
         ),
         KML.altitudeMode("absolute"),
         KML.styleUrl('#sn_shaded_dot'),
         KML.LookAt(
             KML.longitude(pos[1]),
             KML.latitude(pos[0]),
             KML.altitude(pos[2]),
             KML.heading(pos[5]),
             KML.tilt(0.0),
             KML.range(100.0),
             KML.altitudeMode("absolute"),
         ),
         KML.Point(
             KML.coordinates("{lon},{lat},{alt}".format(lon=pos[1], lat=pos[0], alt=pos[2]))
         )
     ))        

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
    def test_basic_kml_document(self):
        """Tests the creation of a basic KML with Google Extensions ."""
        doc = KML.kml(
            GX.Tour(
                GX.Playlist(
                    GX.SoundCue(
                        KML.href('http://dev.keyhole.com/codesite/cntowerfacts.mp3')
                    ),
                    GX.Wait(
                        GX.duration(10)
                    ),
                    GX.FlyTo(
                        GX.duration(5),
                        GX.flyToMode('bounce'),
                        KML.LookAt(
                            KML.longitude(-79.387),
                            KML.latitude(43.643),
                            KML.altitude(0),
                            KML.heading(-172.3),
                            KML.tilt(10),
                            KML.range(1200),
                            KML.altitudeMode('relativeToGround'),
                        )
                    )
                )
            )
        )
        self.assertTrue(Schema('kml22gx.xsd').validate(doc))

        data = etree.tostring(doc, encoding='ascii')
        expected = \
            b'<kml xmlns:gx="http://www.google.com/kml/ext/2.2" ' \
            b'xmlns:atom="http://www.w3.org/2005/Atom" ' \
            b'xmlns="http://www.opengis.net/kml/2.2">' \
            b'<gx:Tour>' \
            b'<gx:Playlist>' \
            b'<gx:SoundCue>' \
            b'<href>http://dev.keyhole.com/codesite/cntowerfacts.mp3</href>' \
            b'</gx:SoundCue>' \
            b'<gx:Wait>' \
            b'<gx:duration>10</gx:duration>' \
            b'</gx:Wait>' \
            b'<gx:FlyTo>' \
            b'<gx:duration>5</gx:duration>' \
            b'<gx:flyToMode>bounce</gx:flyToMode>' \
            b'<LookAt>' \
            b'<longitude>-79.387</longitude>' \
            b'<latitude>43.643</latitude>' \
            b'<altitude>0</altitude>' \
            b'<heading>-172.3</heading>' \
            b'<tilt>10</tilt>' \
            b'<range>1200</range>' \
            b'<altitudeMode>relativeToGround</altitudeMode>' \
            b'</LookAt>' \
            b'</gx:FlyTo>' \
            b'</gx:Playlist>' \
            b'</gx:Tour>' \
            b'</kml>'

        self.assertXmlEquivalentOutputs(data, expected)

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
def build_test_kml():
    """build a simple KML file with a simple LineString, for testing purposes"""

    from pykml.factory import KML_ElementMaker as KML
    from pykml.factory import GX_ElementMaker as GX
    from lxml import etree
    from django.http import HttpResponse

    kml = KML.kml(
        KML.Placemark(
            KML.name("build_test_kml output"),
            KML.LookAt(
                KML.longitude(146.806),
                KML.latitude(12.219),
                KML.heading(-60),
                KML.tilt(70),
                KML.range(6300),
                GX.altitudeMode("relativeToSeaFloor"),
            ),
            KML.LineString(
                KML.extrude(1),
                GX.altitudeMode("relativeToSeaFloor"),
                KML.coordinates(
                    "146.825,12.233,400 "
                    "146.820,12.222,400 "
                    "146.812,12.212,400 "
                    "146.796,12.209,400 "
                    "146.788,12.205,400"
                ),
            ),
        )
    )
    kml_str = etree.tostring(kml)
    return HttpResponse(kml_str, content_type="application/vnd.google-earth.kml")

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
def get_kml_doc(llhs):
  """Generates a KML document from a Pandas table of single point
  solutions. Requires columns lat, lon, and height.

  """
  from pykml.parser import Schema
  from pykml.factory import KML_ElementMaker as KML
  from pykml.factory import GX_ElementMaker as GX
  center = llhs[['lat', 'lon', 'height']].mean()
  elts = lambda e: '%s,%s,%d' % (e['lon'], e['lat'], e['height'])
  coords = ' '.join(llhs.apply(elts, axis=1).values)
  xml_coords = KML.coordinates(coords)
  doc = KML.kml(
          KML.Placemark(
            KML.name("gx:altitudeMode Example"),
            KML.LookAt(
              KML.longitude(center.lon),
              KML.latitude(center.lat),
              KML.heading(center.height),
              KML.tilt(70),
              KML.range(6300),
              GX.altitudeMode("relativeToSeaFloor"),),
            KML.LineString(
              KML.extrude(1),
              GX.altitudeMode("relativeToSeaFloor"),
              xml_coords
            )
          )
        )
  return doc

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
 def kml_addPathPoint(self, pos, dt):
     #pos[0] : latitude
     #pos[1] : longitude
     #pos[2] : altitude
     #pos[3] : roll
     #pos[4] : pitch
     #pos[5] : yaw
     if (pos == None):
         return
     #rospy.logerr(pos)
     
     self.tour_doc.Document[self.gxns+"Tour"].Playlist.append(
         GX.FlyTo(
             GX.duration(dt),
             GX.flyToMode("smooth"),
             #KML.Camera(
             KML.LookAt(
                 KML.latitude(pos[0]),
                 KML.longitude(pos[1]),
                 KML.altitude(pos[2]),
                 KML.heading(pos[5]),
                 #KML.tilt(pos[4] + 90.0),
                 #KML.roll(pos[3]),
                 KML.tilt(pos[4] + 75.0),
                 KML.range(20.0),
                 KML.altitudeMode("absolute"),
             ),
         ),
     )
     
     auxStr = ' {lon},{lat},{alt}\n'.format(lon=pos[1], lat=pos[0], alt=pos[2])
     #rospy.logerr(auxStr)
     self.execCoordListStr = self.execCoordListStr + auxStr

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
 def get_look_at(self):
   return \
     KML.LookAt(
       KML.longitude(self.camera[0]),
       KML.latitude(self.camera[1]),
       KML.altitude(self.camera[2]),
       KML.heading(self.camera[3]),
       KML.tilt(self.camera[4]),
       KML.range(self.camera[5]),
     )

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
def task_to_kml_with_pykml(df_task, outdir, filename_base, disp):
    from lxml import etree
    from pykml.parser import Schema
    from pykml.factory import KML_ElementMaker as KML
    from pykml.factory import GX_ElementMaker as GX

    s_coords = task_to_string(df_task)    
    (lat, lon) = calculate_center(df_task)
    
    #def turn_point_to_placemark(tp):
    #    placemark = KML.Placemark(
    #        KML.name(tp['Name']),
    #        KML.description(tp['Name']),
    #        KML.Point(
    #            KML.coordinates(tp['Lon'], tp['Lat'], tp['Altitude'])
    #        ),
    #    )
    #    return(placemark)
    #placemarks = [turn_point_to_placemark(tp) for i, tp in df_task.iterrows()]

    doc = KML.kml(
        KML.Placemark(
            KML.name("Condor task '%s'" % filename_base),
            KML.LookAt(
                KML.longitude(lon),
                KML.latitude(lat),
                KML.heading(0),
                KML.tilt(60),
                KML.range(80000),
                GX.altitudeMode("relativeToSeaFloor"),
                #GX.altitudeMode("absolute"),
            ),
            KML.LineString(
                KML.extrude(1),
                GX.altitudeMode("relativeToSeaFloor"),
                #GX.altitudeMode("absolute"),
                KML.coordinates(s_coords),
            ),
        ),
        #*placemarks
    )
    if disp:
        print(etree.tostring(doc, pretty_print=True))
    # output a KML file (named based on the Python script)
    filename_out = os.path.join(outdir, filename_base + '.kml')
    print("Output '%s'" % filename_out)
    outfile = file(filename_out,'w')
    outfile.write(etree.tostring(doc, pretty_print=True))

    assert Schema('kml22gx.xsd').validate(doc)

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
def placeMaker(attr):
    '''Uses pyKML to produce a placemark for an image
    
The use of pyKML isn't actually necessary,
you could do just as well appending the placemarks from the NASA
KML files into a single document, but the intention was to
give an example usage of pyKML.'''
    try:
        placemark = K.Placemark(
                        K.open(0),
                        K.name(attr['MRF']),
                        K.styleUrl("#sm_style"),
                        K.Point(
                            K.altitudeMode('relativeToGround'),
                            K.coordinates(",".join([attr["Longitude"],attr["Latitude"],attr["Elevation"]]))
                        ),
                        K.LookAt(
                            K.tilt(attr["Tilt"]),
                            K.longitude(attr["Longitude"]),
                            K.latitude(attr["Latitude"]),
                            K.range(40000)
                        ),
                        K.TimeStamp(K.when(time.strftime("%Y-%m-%dT%H:%M:%SZ",time.strptime(attr["YYYYMMDD"]+attr["HHMMSS"],"%Y%m%d %H%M%S")))),
                        K.ExtendedData(
                            K.Data( K.value(attr["MRF"]), name="MRF"),
                            K.Data( K.value(attr["IMG"]), name="IMG"),
                            K.Data( K.value(attr["Features"]), name="features"),
                            K.Data( K.value(attr["YYYYMMDD"]), name="YYYYMMDD"),
                            K.Data( K.value(attr["HHMMSS"]), name="HHMMSS"),
                            K.Data( K.value(attr["Camera Tilt"]), name="Camera_Tilt"),
                            K.Data( K.value(attr["Camera Lens"]), name="Camera_Lens"),
                            K.Data( K.value(attr["Camera"]), name="Camera"),
                            K.Data( K.value(attr["Sun Azimuth"]), name="Sun_Azimuth"),
                            K.Data( K.value(attr["Sun Elevation"]), name="Sun_Elevation"),
                            K.Data( K.value(attr["Spacecraft Altitude"]), name="Spacecraft_Altitude"),
                            K.Data( K.value(attr["DB Entry"]), name="DB_Entry"),
                        )

                        
                    )
    except :
        return None
    return placemark

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
def point_placemark(origin, name, x, y):
    point = srr.util.local_to_global(origin, x, y)

    return KML.Placemark(
        KML.name(name),
        KML.LookAt(
            KML.longitude(point[0]),
            KML.latitude(point[1]),
            KML.altitude(0),
            KML.heading(origin[2]),
            KML.tilt(0),
            KML.roll(0),
            KML.altitudeMode("relativeToGround"),
            KML.range(DEFAULT_HEIGHT)
        ),
        KML.Point(
            KML.coordinates("{lon},{lat},{alt}".format(
                lon=point[0], lat=point[1], alt=0)),
            )
        )

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
def frame_placemark(origin, name, x, y, theta=0.0,
                    marker='axes.png', scale=1.0, color='ffffffff'):
    frame = srr.util.local_to_global(origin, x, y, theta)

    return KML.Placemark(
        KML.name(name),
        KML.Point(
            KML.coordinates("{lon},{lat},{alt}".format(
                lon=frame[0], lat=frame[1], alt=0)),
            ),
        KML.LookAt(
            KML.longitude(frame[0]),
            KML.latitude(frame[1]),
            KML.altitude(0),
            KML.heading(frame[2]),
            KML.tilt(0),
            KML.roll(0),
            KML.altitudeMode("relativeToGround"),
            KML.range(DEFAULT_HEIGHT)
        ),
        KML.Style(
            KML.IconStyle(
                KML.scale(scale),
                KML.heading(frame[2]),
                KML.color(color),
                KML.Icon(
                    KML.href(flask.url_for('static',
                                           filename=marker,
                                           _external=True)),
                    ),
                KML.hotSpot(x="0.5", y="0.5",
                            xunits="fraction",
                            yunits="fraction")
                ),
            )
        )

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
URL = 'http://curiosityrover.com/drives'

route = json.loads( urllib2.urlopen(URL).read() )

pList = ''
for point in route:
    pList = pList + str(point['lon']) + ',' + str(point['lat']) +',1,'

pm = KML.Placemark(
    KML.name('Curiosity traversal'),
    KML.LookAt(
        KML.longitude(route[0]['lon']),
        KML.latitude(route[0]['lat']),
        KML.heading('0'),
        KML.tilt('40'),
        KML.range('2000'),
        GX.altitudeMode('relativeToSeaFloor'),
        ),
    KML.LineStyle(
        KML.color('#00FFFF'),
        KML.width(10)
    ),
    KML.altitudeMode('clampToGround'),
    KML.LineString(KML.extrude('1'), GX.altitudeMode('relativeToSeaFloor'), KML.coordinates(pList))
    )

folder = KML.Folder()
folder.append(pm)

# create a document element with a single label style
kmlobj = KML.kml(

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
    def makeFile(self):


        # define a variable for the Google Extensions namespace URL string
        gxns = '{' + nsmap['gx'] + '}'

        stylename = "sn_shaded_dot"
        # start with a base KML tour and playlist
        tour_doc = KML.kml(
            KML.Document(
                GX.Tour(
                    KML.name("Play me!"),
                    GX.Playlist(),
                ),
                KML.Folder(
                    KML.name('Features'),
                    id='features',
                ),
                KML.Style(
                    KML.IconStyle(
                        KML.scale(1.2),
                        KML.Icon(
                            KML.href(self.icon)
                        ),
                    ),
                    id=stylename,
                )
            )
        )
        for data in self.data_set:
            # import ipdb; ipdb.set_trace()
            # fly to a space viewpoint
            tour_doc.Document[gxns + "Tour"].Playlist.append(
                GX.FlyTo(
                    GX.duration(5),
                    GX.flyToMode("smooth"),
                    KML.LookAt(
                        KML.longitude(float(data['coordinates']['lng'])),
                        KML.latitude(float(data['coordinates']['lat'])),
                        KML.altitude(0),
                        KML.heading(0),
                        KML.tilt(0),
                        KML.range(10000000.0),
                        KML.altitudeMode("relativeToGround"),
                    )
                ),
            )
            # fly to the data
            tour_doc.Document[gxns + "Tour"].Playlist.append(
                GX.FlyTo(
                    GX.duration(5),
                    GX.flyToMode("bounce"),
                    KML.LookAt(
                        KML.longitude(float(data['coordinates']['lng'])),
                        KML.latitude(float(data['coordinates']['lat'])),
                        KML.altitude(0),
                        KML.heading(0),
                        KML.tilt(data['data']),
                        KML.name(data['data']),
                        KML.range(self.range),
                        KML.altitudeMode("relativeToGround"),
                    )
                ),
            )
            # spin around the data
            for aspect in range(0, 360, 10):
                tour_doc.Document[gxns + "Tour"].Playlist.append(
                    GX.FlyTo(
                        GX.duration(0.25),
                        GX.flyToMode("smooth"),
                        KML.LookAt(
                            KML.longitude(float(data['coordinates']['lng'])),
                            KML.latitude(float(data['coordinates']['lat'])),
                            KML.altitude(0),
                            KML.heading(aspect),
                            KML.tilt(data['data']),
                            KML.name(data['data']),
                            KML.range(self.range),
                            KML.altitudeMode("relativeToGround"),
                        )
                    )
                )
            tour_doc.Document[gxns + "Tour"].Playlist.append(GX.Wait(GX.duration(1.0)))

            # tour_doc.Document[gxns+"Tour"].Playlist.append(
            #        GX.TourControl(GX.playMode("pause"))
            #    )

            # add a placemark for the data
            tour_doc.Document.Folder.append(
                KML.Placemark(
                    KML.name(data['data']),
                    KML.description(
                        "<h1>" + data['data'] + "</h1>"
                    ),
                    KML.styleUrl('#{0}'.format(stylename)),
                    KML.Point(
                        KML.extrude(1),
                        KML.altitudeMode("relativeToGround"),
                        KML.coordinates("{lon},{lat},{alt}".format(
#.........这里部分代码省略.........

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
def main():
    # iterate through 24 hours, adding ephemeris data to a list
    data = []
    for hour in range(0, 24):
        obs.date = date = datetime(year, month, day) + timedelta(hours=hour)
        sun.compute(obs)
        data.append({
            'datetime UTC': date,
            'azimuth_angle': sun.az.real,
            'altitude_angle': sun.alt.real,
        })

    # create a KML file skeleton
    stylename = "sn_shaded_dot"
    doc = KML.kml(
        KML.Document(
            KML.name("Sun Position"),
            KML.Style(
                KML.IconStyle(
                    KML.scale(1.2),
                    KML.Icon(
                        KML.href("http://maps.google.com/mapfiles/kml/shapes/shaded_dot.png")
                    ),
                ),
                id=stylename,
            )
        )
    )
    # create placemark for the observer, and add it to the KML document
    pm_observer = KML.Placemark(
        KML.name('Observer'),
        KML.styleUrl('#{0}'.format(stylename)),
        KML.Point(
            KML.extrude(True),
            KML.altitudeMode('relativeToGround'),
            KML.coordinates("{0},{1},{2}".format(longitude, latitude, height)),
        ),
    )
    doc.Document.append(pm_observer)
    # iterate through the ephemeris data
    for i in data:
        timestamp = i['datetime UTC']
        azimuth_rad = i['azimuth_angle']
        azimuth_deg = degrees(azimuth_rad)
        altitude_rad = i['altitude_angle']
        altitude_deg = degrees(altitude_rad)
        if altitude_deg > 0:
            # define a placemark along the ephemeris vector for labeling
            delta_lat_rad, delta_lon_rad, delta_alt = calculate_geographic_offset(
                azimuth_angle=radians(adjust_heading_degrees(degrees(azimuth_rad))),
                altitude_angle=altitude_rad,
                distance=label_distance,
            )
            pm1 = KML.Placemark(
                KML.name((timestamp + timedelta(timezone_offset)).strftime('%H:%M')),
                KML.styleUrl('#{0}'.format(stylename)),
                KML.LookAt(
                    KML.longitude(longitude),
                    KML.latitude(latitude),
                    KML.altitude(height),
                    KML.heading(adjust_heading_degrees(azimuth_deg)),
                    KML.tilt(90),
                    # KML.roll(0),
                    KML.altitudeMode("relativeToGround"),
                    KML.range(50),
                ),
                KML.Point(
                    KML.altitudeMode("relativeToGround"),
                    KML.coordinates("{lon},{lat},{alt}".format(
                        lon=longitude + degrees(delta_lon_rad),
                        lat=latitude + degrees(delta_lat_rad),
                        alt=height + delta_alt,
                    )),
                ),
            )
            pm2 = KML.Placemark(
                KML.name('Sun View'),
                KML.LookAt(
                    KML.longitude(longitude),
                    KML.latitude(latitude),
                    KML.altitude(height),
                    KML.heading(adjust_heading_degrees(180 + azimuth_deg)),
                    KML.tilt(90 - altitude_deg - 0.2),
                    # KML.roll(0),
                    KML.altitudeMode("relativeToGround"),
                    KML.range(2 * label_distance),
                ),
                KML.Model(
                    KML.altitudeMode('relativeToGround'),
                    KML.Location(
                        KML.longitude(longitude),
                        KML.latitude(latitude),
                        KML.altitude(height),
                    ),
                    KML.Orientation(
                        KML.heading(adjust_heading_degrees(azimuth_deg)),
                        KML.tilt(90 - altitude_deg),
                        KML.roll(0),
                    ),
                    KML.Scale(
#.........这里部分代码省略.........

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
     azimuth_angle=radians(adjust_heading_degrees(degrees(azimuth_rad))),
     altitude_angle=altitude_rad,
     distance=label_distance,
 )
 pm1 = KML.Placemark(
     KML.name((timestamp+timedelta(timezone_offset)).strftime('%H:%M')),
     KML.styleUrl('#{0}'.format(stylename)),
     KML.LookAt(
         KML.longitude(longitude),
         KML.latitude(latitude),
         KML.altitude(height),
         KML.heading(adjust_heading_degrees(azimuth_deg)),
         KML.tilt(90),
         KML.roll(0),
         KML.altitudeMode("relativeToGround"),
         KML.range(50),
     ),
     KML.Point(
         KML.altitudeMode("relativeToGround"),
         KML.coordinates("{lon},{lat},{alt}".format(
             lon = longitude + degrees(delta_lon_rad),
             lat = latitude + degrees(delta_lat_rad),
             alt = height + delta_alt,
         )),
     ),
 )
 pm2 = KML.Placemark(
     KML.name('Sun View'),
     KML.LookAt(
         KML.longitude(longitude),
         KML.latitude(latitude),

# 需要导入模块: from pykml.factory import KML_ElementMaker [as 别名]
# 或者: from pykml.factory.KML_ElementMaker import range [as 别名]
'''

from lxml import etree
from pykml.parser import Schema
from pykml.factory import KML_ElementMaker as KML
from pykml.factory import GX_ElementMaker as GX

doc = KML.kml(
    KML.Placemark(
        KML.name("gx:altitudeMode Example"),
        KML.LookAt(
            KML.longitude(146.806),
            KML.latitude(12.219),
            KML.heading(-60),
            KML.tilt(70),
            KML.range(6300),
            GX.altitudeMode("relativeToSeaFloor"),
        ),
        KML.LineString(
            KML.extrude(1),
            GX.altitudeMode("relativeToSeaFloor"),
            KML.coordinates(
              "146.825,12.233,400 "
              "146.820,12.222,400 "
              "146.812,12.212,400 "
              "146.796,12.209,400 "
              "146.788,12.205,400"
            )
        )
    )
)