示例#1
0
 def testPolygon(self):
     p = czml.Polygon()
     m = czml.Material()
     sc = czml.SolidColor(color={'rgba': [0, 255, 127, 55]})
     m.solidColor = sc
     p.material = m
     self.assertEqual(p.data(),
         {'material':
             {'solidColor':
                 {'color': {'rgba': [0, 255, 127, 55]}}
         }   }
         )
     p2 = czml.Polygon()
     p2.loads(p.dumps())
     self.assertEqual(p.data(), p2.data())
     p3 = czml.Polygon(color={'rgba': [0, 255, 127, 55]})
     self.assertEqual(p.data(), p3.data())
示例#2
0
    def testCZMLPacket(self):
        p = czml.CZMLPacket(id='abc')
        self.assertEqual(p.dumps(), '{"id": "abc"}')
        bb = czml.Billboard()
        bb.image = 'http://localhost/img.png'
        bb.scale = 0.7
        bb.show = True
        p.billboard = bb
        self.assertEqual(p.data(),
            {'billboard': {'image': 'http://localhost/img.png',
            'scale': 0.7, 'show': True}, 'id': 'abc'})
        p2 = czml.CZMLPacket(id='abc')
        p2.loads(p.dumps())
        self.assertEqual(p.data(), p2.data())
        pos = czml.Position()
        coords = [7.0, 0.0, 1.0, 2.0, 6.0, 3.0, 4.0, 5.0]
        pos.cartesian = coords
        p.position = pos
        l = czml.Label()
        l.text = 'test label'
        l.show = False
        p.label = l
        self.assertEqual(p.data(),
            {'billboard': {'image': 'http://localhost/img.png',
            'scale': 0.7, 'show': True}, 'id': 'abc',
            'label': {'show': False, 'text': 'test label'},
            'position': {'cartesian': [7.0, 0.0, 1.0, 2.0, 6.0, 3.0, 4.0, 5.0]},
            })
        p2.loads(p.dumps())
        self.assertEqual(p.data(), p2.data())
        p3 = czml.CZMLPacket(id='cde')
        p3.point = {'color':
                    {'rgba': [0, 255, 127, 55]},
                    'show': True}
        self.assertEqual(p3.data(), {'id': 'cde',
                                    'point': {'color':
                                        {'rgba': [0, 255, 127, 55]},
                                        'show': True}})
        p32 = czml.CZMLPacket(id='abc')
        p32.loads(p3.dumps())
        self.assertEqual(p3.data(), p32.data())
        p4 = czml.CZMLPacket(id='defg')

        pl = czml.Polyline()
        pl.color = {'rgba': [0, 255, 127, 55]}
        pl.width = 10
        pl.outlineWidth = 2
        pl.show = True
        v = czml.VertexPositions()
        v.cartographicDegrees = [0.0, 0.0, .0, 1.0, 1.0, 1.0]
        p4.vertexPositions = v
        p4.polyline = pl
        self.assertEqual(p4.data(),
             {'polyline':
                {'color': {'rgba': [0, 255, 127, 55]},
                'width': 10,
                'outlineWidth': 2,
                'show': True},
            'id': 'defg',
            'vertexPositions':
                {'cartographicDegrees':
                    [0.0, 0.0, 0.0, 1.0, 1.0, 1.0]}
            })
        p42 = czml.CZMLPacket(id='abc')
        p42.loads(p4.dumps())
        self.assertEqual(p4.data(), p42.data())
        p5 = czml.CZMLPacket(id='efgh')
        p5.vertexPositions = v
        poly = czml.Polygon(color={'rgba': [0, 255, 127, 55]})
        p5.polygon = poly
        self.assertEqual(p5.data(),
            {'polygon':
                {'material':
                    {'solidColor':
                        {'color':
                            {'rgba': [0, 255, 127, 55]}}}},
                    'id': 'efgh',
                    'vertexPositions':
                        {'cartographicDegrees':
                            [0.0, 0.0, 0.0, 1.0, 1.0, 1.0]}})
        p52 = czml.CZMLPacket(id='abc')
        p52.loads(p5.dumps())
        self.assertEqual(p5.data(), p52.data())
        return p
示例#3
0
    def testPolygon(self):

        # Create a new polygon
        img = czml.Image(image='http://localhost/img.png', repeat=2)
        mat = czml.Material(image=img)
        pts = geometry.LineString([(50, 20, 2), (60, 30, 3), (50, 30, 4),
                                   (60, 20, 5)])
        pos = czml.Positions(cartographicDegrees=pts)
        col = {'rgba': [0, 255, 127, 55]}
        pol = czml.Polygon(show=True,
                           material=mat,
                           positions=pos,
                           perPositionHeight=True,
                           fill=True,
                           outline=True,
                           outlineColor=col)
        self.assertEqual(
            pol.data(), {
                'show': True,
                'fill': True,
                'outline': True,
                'perPositionHeight': True,
                'outlineColor': {
                    'rgba': [0, 255, 127, 55]
                },
                'material': {
                    'image': {
                        'image': 'http://localhost/img.png',
                        'repeat': 2
                    },
                },
                'positions': {
                    'cartographicDegrees':
                    [50, 20, 2, 60, 30, 3, 50, 30, 4, 60, 20, 5]
                },
            })

        # Create a new polygon from an existing polygon
        pol2 = czml.Polygon()
        pol2.loads(pol.dumps())
        self.assertEqual(pol2.data(), pol.data())

        # Modify an existing polygon
        grid = czml.Grid(color={'rgba': [0, 55, 127, 255]},
                         cellAlpha=0.4,
                         lineCount=5,
                         lineThickness=2,
                         lineOffset=0.3)
        mat2 = czml.Material(grid=grid)
        pts2 = geometry.LineString([(1.5, 1.2, 0), (1.6, 1.3, 0),
                                    (1.5, 1.3, 0), (1.6, 1.2, 0)])
        pos2 = czml.Positions(cartographicRadians=pts2)
        pol2.material = mat2
        pol2.positions = pos2
        pol2.perPositionHeight = False
        pol2.height = 7
        pol2.extrudedHeight = 30
        self.assertEqual(
            pol2.data(), {
                'show': True,
                'fill': True,
                'outline': True,
                'perPositionHeight': False,
                'height': 7,
                'extrudedHeight': 30,
                'outlineColor': {
                    'rgba': [0, 255, 127, 55]
                },
                'material': {
                    'grid': {
                        'color': {
                            'rgba': [0, 55, 127, 255]
                        },
                        'cellAlpha': 0.4,
                        'lineCount': 5,
                        'lineThickness': 2,
                        'lineOffset': 0.3
                    },
                },
                'positions': {
                    'cartographicRadians':
                    [1.5, 1.2, 0, 1.6, 1.3, 0, 1.5, 1.3, 0, 1.6, 1.2, 0]
                },
            })

        # Add a polygon to a CZML packet
        packet = czml.CZMLPacket(id='abc')
        packet.polygon = pol2
        self.assertEqual(
            packet.data(), {
                'id': 'abc',
                'polygon': {
                    'show': True,
                    'fill': True,
                    'outline': True,
                    'perPositionHeight': False,
                    'height': 7,
                    'extrudedHeight': 30,
                    'outlineColor': {
                        'rgba': [0, 255, 127, 55]
                    },
                    'material': {
                        'grid': {
                            'color': {
                                'rgba': [0, 55, 127, 255]
                            },
                            'cellAlpha': 0.4,
                            'lineCount': 5,
                            'lineThickness': 2,
                            'lineOffset': 0.3
                        },
                    },
                    'positions': {
                        'cartographicRadians':
                        [1.5, 1.2, 0, 1.6, 1.3, 0, 1.5, 1.3, 0, 1.6, 1.2, 0]
                    },
                },
            })
示例#4
0
    def czml(self):

        doc = czml.CZML();
        iso = self.date.isoformat()

        # Generate time-specific lists for various objects
        central_polyline_degrees = []
        north_polyline_degrees = []
        south_polyline_degrees = []
        ellipse_position = []
        ellipse_semiMajorAxis = []
        ellipse_semiMinorAxis = []
        ellipse_rotation = []

        for t in range(len(self.time)):

            time = iso + "T" + self.time[t] + ":00Z"

            # Define polyline waypoints only where data exist
            if self.position['north'][t] != None:
                north_polyline_degrees += [self.position['north'][t][0], self.position['north'][t][1], 0.0]
            if self.position['central'][t] != None:
                central_polyline_degrees += [self.position['central'][t][0], self.position['central'][t][1], 0.0]
            if self.position['south'][t] != None:
                south_polyline_degrees += [self.position['south'][t][0], self.position['south'][t][1], 0.0]

            # Define ellipse positions and attributes for every time in the interval, using limits where necessary
            use_limit = min(int(math.floor(t/(len(self.time)/2))),1)
            if self.position['north'][t] == None:
                north = self.limits['north'][use_limit]
            else:
                north = self.position['north'][t]
            if self.position['central'][t] == None:
                central = self.limits['central'][use_limit]
            else:
                central = self.position['central'][t]
            if self.position['south'][t] == None:
                south = self.limits['south'][use_limit]
            else:
                south = self.position['south'][t]

            # Approximate ellipse semiMajorAxis from vincenty distance between limit polylines
            north2 = (north[1], north[0])
            south2 = (south[1], south[0])
            semi_major_axis = vincenty(north2, south2).meters / 2

            # Approximate elipse semiMinorAxis from sun altitude (probably way wrong!)
            ellipse_axis_ratio = self.sun_altitude[t] / 90
            semi_minor_axis = semi_major_axis * ellipse_axis_ratio

            # Approximate ellipse rotation using basic spheroid (TODO: replace with WGS-84)
            # Calculate bearing in both directions and average them
            nlat = north[1]/180 * math.pi;
            nlon = north[0]/180 * math.pi;
            clat = central[1]/180 * math.pi;
            clon = central[0]/180 * math.pi;
            slat = south[1]/180 * math.pi;
            slon = south[0]/180 * math.pi;

            y = math.sin(slon-nlon) * math.cos(slat);
            x = math.cos(nlat) * math.sin(slat) - math.sin(nlat) * math.cos(slat) * math.cos(slon-nlon);
            initial_bearing = math.atan2(y, x)
            if (initial_bearing < 0):
                initial_bearing += math.pi * 2

            y = math.sin(nlon-slon) * math.cos(nlat);
            x = math.cos(slat) * math.sin(nlat) - math.sin(slat) * math.cos(nlat) * math.cos(nlon-slon);
            final_bearing = math.atan2(y, x) - math.pi
            if (final_bearing < 0):
                final_bearing += math.pi * 2

            rotation = -1 * ((initial_bearing + final_bearing) / 2 - (math.pi / 2))

            ellipse_position += [time, central[0], central[1], 0.0]
            ellipse_semiMajorAxis += [time, round(semi_major_axis, 3)]
            ellipse_semiMinorAxis += [time, round(semi_minor_axis, 3)]
            ellipse_rotation += [time, round(rotation, 3)]        

        # Generate document packet with clock
        start_time = iso + "T" + self.time[0] + ":00Z"
        end_time = iso + "T" + self.time[-1] + ":00Z"
        packet = czml.CZMLPacket(id='document',version='1.0')
        c = czml.Clock()
        c.multiplier = 300
        c.range = "LOOP_STOP"
        c.step = "SYSTEM_CLOCK_MULTIPLIER"
        c.currentTime = start_time
        c.interval = start_time + "/" + end_time
        packet.clock = c
        doc.packets.append(packet)

        # Generate a polyline packet for the north and south polylines, connected and filled
        limit_polyline_degrees = list(north_polyline_degrees)
        point = len(south_polyline_degrees)/3
        while (point > 0):
            offset = (point-1) * 3
            limit_polyline_degrees += [ south_polyline_degrees[offset],
                                        south_polyline_degrees[offset+1],
                                        south_polyline_degrees[offset+2] ]
            point -= 1
        packet_id = iso + '_bounds_polygon'
        packet = czml.CZMLPacket(id=packet_id)
        boc = czml.Color(rgba=(232, 72, 68, 255))
        bsc = czml.SolidColor(color=czml.Color(rgba=(0, 0, 0, 66)))
        bmat = czml.Material(solidColor=bsc)
        bdeg = limit_polyline_degrees
        bpos = czml.Positions(cartographicDegrees=bdeg)
        bpg = czml.Polygon(show=True, height=0, outline=True, outlineColor=boc, outlineWidth=2, material=bmat, positions=bpos)
        packet.polygon = bpg
        doc.packets.append(packet)

        # Generate central polyline packet
        packet_id = iso + '_central_polyline'
        packet = czml.CZMLPacket(id=packet_id)
        csc = czml.SolidColor(color=czml.Color(rgba=(241, 226, 57, 255)))
        cmat = czml.Material(solidColor=csc)
        cpos = czml.Positions(cartographicDegrees=central_polyline_degrees)
        cpl = czml.Polyline(show=True, width=4, followSurface=True, material=cmat, positions=cpos)
        packet.polyline = cpl
        doc.packets.append(packet)

        # Generate ellipse shadow packet
        packet_id = iso + '_shadow_ellipse'
        packet = czml.CZMLPacket(id=packet_id)
        esc = czml.SolidColor(color=czml.Color(rgba=(0, 0, 0, 160)))
        emat = czml.Material(solidColor=esc)
        xmaj = czml.Number(ellipse_semiMajorAxis)
        xmin = czml.Number(ellipse_semiMinorAxis)
        rot = czml.Number(ellipse_rotation)
        ell = czml.Ellipse(show=True, fill=True, granularity=0.002, material=emat, semiMajorAxis=xmaj, semiMinorAxis=xmin, rotation=rot)
        packet.ellipse = ell
        packet.position = czml.Position(cartographicDegrees=ellipse_position)
        doc.packets.append(packet)

        return list(doc.data())