source: subversion/applications/utils/mod_tile/render_list.c @ 8961

Last change on this file since 8961 was 8425, checked in by jonb, 11 years ago

mod_tile: Move map style & font location into render_config.h. Fix up operation with non-metatile rendering. Several utilities are not implemented for non-metatile (render_list, render_old, speedtest).

File size: 7.0 KB
Line 
1#define _GNU_SOURCE
2
3#include <stdio.h>
4#include <stdlib.h>
5#include <unistd.h>
6#include <sys/types.h>
7#include <sys/socket.h>
8#include <sys/stat.h>
9#include <sys/time.h>
10#include <sys/un.h>
11#include <poll.h>
12#include <errno.h>
13#include <math.h>
14#include <getopt.h>
15#include <time.h>
16#include <limits.h>
17
18#include "gen_tile.h"
19#include "protocol.h"
20#include "render_config.h"
21#include "dir_utils.h"
22
23#ifndef METATILE
24#warning("render_list not implemented for non-metatile mode. Feel free to submit fix")
25int main(int argc, char **argv)
26{
27    fprintf(stderr, "render_list not implemented for non-metatile mode. Feel free to submit fix!\n");
28    return -1;
29}
30#else
31
32#define DEG_TO_RAD (M_PIl/180)
33#define RAD_TO_DEG (180/M_PIl)
34
35static int minZoom = 0;
36static int maxZoom = 18;
37static int verbose = 0;
38
39void display_rate(struct timeval start, struct timeval end, int num) 
40{
41    int d_s, d_us;
42    float sec;
43
44    d_s  = end.tv_sec  - start.tv_sec;
45    d_us = end.tv_usec - start.tv_usec;
46
47    sec = d_s + d_us / 1000000.0;
48
49    printf("Rendered %d tiles in %.2f seconds (%.2f tiles/s)\n", num, sec, num / sec);
50    fflush(NULL);
51}
52
53static time_t getPlanetTime(void)
54{
55    static time_t last_check;
56    static time_t planet_timestamp;
57    time_t now = time(NULL);
58    struct stat buf;
59
60    // Only check for updates periodically
61    if (now < last_check + 300)
62        return planet_timestamp;
63
64    last_check = now;
65    if (stat(PLANET_TIMESTAMP, &buf)) {
66        fprintf(stderr, "Planet timestamp file " PLANET_TIMESTAMP " is missing");
67        // Make something up
68        planet_timestamp = now - 3 * 24 * 60 * 60;
69    } else {
70        if (buf.st_mtime != planet_timestamp) {
71            fprintf(stderr, "Planet file updated at %s", ctime(&buf.st_mtime));
72            planet_timestamp = buf.st_mtime;
73        }
74    }
75    return planet_timestamp;
76}
77
78int process_loop(int fd, int x, int y, int z)
79{
80    struct protocol cmd, rsp;
81    //struct pollfd fds[1];
82    int ret = 0;
83
84    bzero(&cmd, sizeof(cmd));
85
86    cmd.ver = 1;
87    cmd.cmd = cmdRender;
88    cmd.z = z;
89    cmd.x = x;
90    cmd.y = y;
91    //strcpy(cmd.path, "/tmp/foo.png");
92
93        //printf("Sending request\n");
94    ret = send(fd, &cmd, sizeof(cmd), 0);
95    if (ret != sizeof(cmd)) {
96        perror("send error");
97    }
98        //printf("Waiting for response\n");
99    bzero(&rsp, sizeof(rsp));
100    ret = recv(fd, &rsp, sizeof(rsp), 0);
101    if (ret != sizeof(rsp)) {
102        perror("recv error");
103        return 0;
104    }
105        //printf("Got response\n");
106
107    if (!ret)
108        perror("Socket send error");
109    return ret;
110}
111
112
113int main(int argc, char **argv)
114{
115    const char *spath = RENDER_SOCKET;
116    int fd;
117    struct sockaddr_un addr;
118    int ret=0;
119    int x, y, z;
120    char name[PATH_MAX];
121    struct timeval start, end;
122    int num_render = 0, num_all = 0;
123    time_t planetTime = getPlanetTime();
124    int c;
125
126    while (1) {
127        int option_index = 0;
128        static struct option long_options[] = {
129            {"min-zoom", 1, 0, 'z'},
130            {"max-zoom", 1, 0, 'Z'},
131            {"verbose", 0, 0, 'v'},
132            {"help", 0, 0, 'h'},
133            {0, 0, 0, 0}
134        };
135
136        c = getopt_long(argc, argv, "hvz:Z:", long_options, &option_index);
137        if (c == -1)
138            break;
139
140        switch (c) {
141            case 'z':
142                minZoom=atoi(optarg);
143                if (minZoom < 0 || minZoom > 18) {
144                    fprintf(stderr, "Invalid minimum zoom selected, must be between 0 and 18\n");
145                    return 1;
146                }
147                break;
148            case 'Z':
149                maxZoom=atoi(optarg);
150                if (maxZoom < 0 || maxZoom > 18) {
151                    fprintf(stderr, "Invalid maximum zoom selected, must be between 0 and 18\n");
152                    return 1;
153                }
154                break;
155            case 'v':
156                verbose=1;
157                break;
158            case 'h':
159                fprintf(stderr, "Send a list of tiles to be rendered from STDIN in the format:\n");
160                fprintf(stderr, "\tX    Y    Z\n");
161                fprintf(stderr, "e.g.\n");
162                fprintf(stderr, "\t0    0    1\n");
163                fprintf(stderr, "\t0    1    1\n");
164                fprintf(stderr, "\t1    0    1\n");
165                fprintf(stderr, "\t1    1    1\n");
166                fprintf(stderr, "The above would cause all 4 tiles at zoom 1 to be rendered\n");
167                fprintf(stderr, "\t-z|--min-zoom\tFilter input to only render tiles greater or equal this zoom level (default 0)\n");
168                fprintf(stderr, "\t-Z|--max-zoom\tFilter input to only render tiles less than or equal to this zoom level (default 18)\n");
169                return -1;
170            default:
171                fprintf(stderr, "unhandled char '%c'\n", c);
172                break;
173        }
174    }
175
176    if (maxZoom < minZoom) {
177        fprintf(stderr, "Invalid zoom range, max zoom must be greater or equal to minimum zoom\n");
178        return 1;
179    }
180
181    fprintf(stderr, "Rendering client\n");
182
183    fd = socket(PF_UNIX, SOCK_STREAM, 0);
184    if (fd < 0) {
185        fprintf(stderr, "failed to create unix socket\n");
186        exit(2);
187    }
188
189    bzero(&addr, sizeof(addr));
190    addr.sun_family = AF_UNIX;
191    strncpy(addr.sun_path, spath, sizeof(addr.sun_path));
192
193    if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
194        fprintf(stderr, "socket connect failed for: %s\n", spath);
195        close(fd);
196        exit(3);
197    }
198
199    gettimeofday(&start, NULL);
200
201    while(!feof(stdin)) {
202        struct stat s;
203        int n = fscanf(stdin, "%d %d %d", &x, &y, &z);
204
205        if (n != 3) {
206            // Discard input line
207            char tmp[1024];
208            char *r = fgets(tmp, sizeof(tmp), stdin);
209            if (!r)
210                continue;
211            // fprintf(stderr, "bad line %d: %s", num_all, tmp);
212            continue;
213        }
214
215        if (z < minZoom || z > maxZoom)
216            continue;
217
218        printf("got: x(%d) y(%d) z(%d)\n", x, y, z);
219
220        num_all++;
221        xyz_to_path(name, sizeof(name), x, y, z);
222
223        if ((stat(name, &s) < 0) || (planetTime > s.st_mtime)) {
224            // missing or old, render it
225            ret = process_loop(fd, x, y, z);
226            num_render++;
227            if (!(num_render % 10)) {
228                gettimeofday(&end, NULL);
229                printf("\n");
230                printf("Meta tiles rendered: ");
231                display_rate(start, end, num_render);
232                printf("Total tiles rendered: ");
233                display_rate(start, end, num_render * METATILE * METATILE);
234                printf("Total tiles handled from input: ");
235                display_rate(start, end, num_all);
236            }
237        }
238    }
239    gettimeofday(&end, NULL);
240    printf("\nTotal for all tiles rendered\n");
241    printf("Meta tiles rendered: ");
242    display_rate(start, end, num_render);
243    printf("Total tiles rendered: ");
244    display_rate(start, end, num_render * METATILE * METATILE);
245    printf("Total tiles handled: ");
246    display_rate(start, end, num_all);
247
248    close(fd);
249    return ret;
250}
251#endif
Note: See TracBrowser for help on using the repository browser.