int main(int argc, char *argv[])
{
scew_parser *parser = NULL;
if (init() != 0) {
return 1;
}
if (argc == 2) {
if (exists(argv[1])) {
parser = scew_parser_create();
scew_parser_ignore_whitespaces(parser, 1);
scew_parser_load_file(parser, argv[1]);
maptree = scew_parser_tree(parser);
} else {
allegro_message("Cannot load file: %s", argv[1]);
close_program = 1;
}
} else if (argc == 4) {
maptree = new_map(0, MAP_WIN.w / TILE_W, atoi(argv[1]), 1, argv[2]);
map_offset = atoi(argv[1]) * TILE_H - EDITOR_WIN_H;
} else {
/* print usage */
allegro_message
("Usage:\n\"editor.exe <filename>\" to load a file\n \"editor.exe <height_in_tiles> <default_tile_name> <newmapfile>\" to create a new map");
close_program = 1;
}
while (!close_program) {
/* get input */
parse_mouse();
get_grid_item();
if (keypressed()) {
parse_keyboard();
}
/* blit virtual screen */
clear_to_color(vscreen, DEAD_COLOR);
draw_select_lists(vscreen);
draw_ctrl_box(vscreen);
update_screen();
}
if (argc == 2) {
write_map(argv[1], maptree);
scew_parser_free(parser);
} else if (argc == 4) {
write_map(argv[3], maptree);
scew_tree_free(maptree);
}
destroy_bitmap(vscreen);
cleanup();
return 0;
}
void init_maps(void)
{
uint32 i = 0;
uint32 n = 0;
char *path;
map_array = (map_t *)calloc(MAX_MAPS, sizeof(map_t));
map_array_cache = (buffer_t *)calloc(MAX_MAPS, sizeof(buffer_t));
for( i = 0; i < MAX_MAPS; i++){
map_array[i].name = (char *)calloc(MAX_NAME_LENGTH, sizeof(char));
map_array[i].npc = (map_npc_t *)calloc(MAX_MAP_NPCS, sizeof(map_npc_t));
map_array[i].tile = (tile_t *)calloc(MAX_MAPX * MAX_MAPY, sizeof(tile_t));
map_array[i].items = (map_item_t *)calloc(MAX_MAP_ITEMS, sizeof(map_item_t));
for( n = 0; n < MAX_MAP_NPCS; n++)
map_array[i].npc[n].vitals = (uint16 *)calloc(VITAL_COUNT, sizeof(uint16));
path = get_path(MAP_PATH, i, FILE_ENDING);
check_dir(MAP_PATH);
if(file_readable(path))
read_map(path,i);
else
write_map(path,i);
mapcache_create(i);
}
}
int avro_schema_to_json(const avro_schema_t schema, avro_writer_t out)
{
check_param(EINVAL, is_avro_schema(schema), "schema");
check_param(EINVAL, out, "writer");
int rval;
if (is_avro_primitive(schema)) {
check(rval, avro_write_str(out, "{\"type\":\""));
}
switch (avro_typeof(schema)) {
case AVRO_STRING:
check(rval, avro_write_str(out, "string"));
break;
case AVRO_BYTES:
check(rval, avro_write_str(out, "bytes"));
break;
case AVRO_INT32:
check(rval, avro_write_str(out, "int"));
break;
case AVRO_INT64:
check(rval, avro_write_str(out, "long"));
break;
case AVRO_FLOAT:
check(rval, avro_write_str(out, "float"));
break;
case AVRO_DOUBLE:
check(rval, avro_write_str(out, "double"));
break;
case AVRO_BOOLEAN:
check(rval, avro_write_str(out, "boolean"));
break;
case AVRO_NULL:
check(rval, avro_write_str(out, "null"));
break;
case AVRO_RECORD:
return write_record(out, avro_schema_to_record(schema));
case AVRO_ENUM:
return write_enum(out, avro_schema_to_enum(schema));
case AVRO_FIXED:
return write_fixed(out, avro_schema_to_fixed(schema));
case AVRO_MAP:
return write_map(out, avro_schema_to_map(schema));
case AVRO_ARRAY:
return write_array(out, avro_schema_to_array(schema));
case AVRO_UNION:
return write_union(out, avro_schema_to_union(schema));
case AVRO_LINK:
return write_link(out, avro_schema_to_link(schema));
}
if (is_avro_primitive(schema)) {
return avro_write_str(out, "\"}");
}
avro_set_error("Unknown schema type");
return EINVAL;
}
void write_maps(char *prefix_out,int nside,int n_nu,
flouble **maps_i,flouble **maps_q,
flouble **maps_u)
{
long ii;
int with_pol,nfields;
flouble *map_aux_q,*map_aux_u;
printf("*** Writing maps %s_###.fits\n",prefix_out);
if(maps_q==NULL) {
with_pol=0;
nfields=1;
map_aux_q=NULL;
map_aux_u=NULL;
}
else {
with_pol=1;
nfields=3;
map_aux_q=(flouble *)my_malloc(nside2npix(nside)*sizeof(flouble));
map_aux_u=(flouble *)my_malloc(nside2npix(nside)*sizeof(flouble));
}
map_aux=(float **)my_malloc(nfields*sizeof(float *));
for(ii=0;ii<nfields;ii++)
map_aux[ii]=(float *)my_malloc(nside2npix(nside)*sizeof(float));
timer(0);
for(ii=0;ii<n_nu;ii++) {
char fname[256];
if(with_pol) {
he_udgrade(maps_q[ii],NSIDE_POL,map_aux_q,nside,0);
he_udgrade(maps_u[ii],NSIDE_POL,map_aux_u,nside,0);
}
sprintf(fname,"%s_%03ld.fits",prefix_out,ii+1);
write_map(fname,nside,maps_i[ii],map_aux_q,map_aux_u);
}
for(ii=0;ii<nfields;ii++)
free(map_aux[ii]);
free(map_aux);
if(with_pol) {
free(map_aux_q);
free(map_aux_u);
}
timer(1);
printf("\n");
}
int main(void)
{
if ((ipass=fopen(scans,"r"))==NULL)
{
printf("Cannot open file. \n");
exit(1);
}
fscanf(ipass,"%i", &Ptotal);
for (Pindex=1; Pindex<=Ptotal; Pindex++)
{
fscanf(ipass,"%s", powerfile);
// printf("%s\n",powerfile);
if ((fp=fopen(powerfile,"r"))==NULL)
{
printf("Cannot open file. \n");
exit(1);
}
strcpy(passfile,"");
strcat(passfile,prefix);
p=strpbrk(powerfile,"2");
strcat(passfile,p);
// printf("%s\n",passfile);
if ((fpass=fopen(passfile,"r"))==NULL)
{
printf("Cannot open file. \n");
exit(1);
}
printf("\nReading data file %s \n",powerfile);
for (acqcount=1; acqcount < (numofacqs+1); acqcount++) read_data();
read_pass_file();
// test_data();
fclose(fpass);
fclose(fp);
}
group_data();
pg_id = cpgopen("/XSERVE");
while (sat_choice <100)
{
printf("\nPlot Satellite: ");
scanf("%i", &sat_choice);
if (sat_choice<40) plot_map();
}
write_map();
fclose(ipass);
printf("End of Program\n");
return 0;
}
void test_map(uint32 mapnum)
{
uint32 x = 0;
uint32 y = 0;
char *path;
map(mapnum)->name = "A Test Map";
map(mapnum)->moral = 0;
map(mapnum)->music = 0;
map(mapnum)->left = 0;
map(mapnum)->right = 0;
map(mapnum)->up = 0;
map(mapnum)->down = 0;
map(mapnum)->shop = 0;
map(mapnum)->bootmap = 1;
map(mapnum)->bootx = 4;
map(mapnum)->booty = 4;
map(mapnum)->revision = 1;
for( x = 0; x < MAX_MAP_NPCS; x++)
map(mapnum)->npc[x].num = 0;
for( y = 0; y < MAX_MAPY; y++){
for( x = 0; x < MAX_MAPX; x++){
map(mapnum)->tile[GETXY(x,y)].ground.y = 1;
map(mapnum)->tile[GETXY(x,y)].ground.x = 1;
map(mapnum)->tile[GETXY(x,y)].ground.tileset = 1;
map(mapnum)->tile[GETXY(x,y)].mask.y = 0;
map(mapnum)->tile[GETXY(x,y)].mask.x = 0;
map(mapnum)->tile[GETXY(x,y)].mask.tileset = 0;
map(mapnum)->tile[GETXY(x,y)].anim.y = 0;
map(mapnum)->tile[GETXY(x,y)].anim.x = 0;
map(mapnum)->tile[GETXY(x,y)].anim.tileset = 0;
map(mapnum)->tile[GETXY(x,y)].fringe.y = 0;
map(mapnum)->tile[GETXY(x,y)].fringe.x = 0;
map(mapnum)->tile[GETXY(x,y)].fringe.tileset = 0;
map(mapnum)->tile[GETXY(x,y)].data1 = 0;
map(mapnum)->tile[GETXY(x,y)].data2 = 0;
map(mapnum)->tile[GETXY(x,y)].data3 = 0;
map(mapnum)->tile[GETXY(x,y)].type = TILE_TYPE_WALKABLE;
}
}
path = get_path(MAP_PATH, mapnum, FILE_ENDING);
write_map(path,mapnum);
}
int main(int argc, const char * argv[]) {
namespace prog_opt = boost::program_options;
namespace file_sys = boost::filesystem;
///////////////////////////////////////////////////////////////////////////
/// ///
/// PROGRAM OPTIONS ///
/// ///
///////////////////////////////////////////////////////////////////////////
std::string base_dir_str;
std::string output_path_str;
bool use_int_signals;
std::string climate_signal;
std::vector<std::string> portfolio_signal;
int ari_signal;
int year;
prog_opt::options_description desc("Allowed options");
desc.add_options()
("help,h", "produce help message")
("base-directory,d", prog_opt::value<std::string>(&base_dir_str), "The base directory for the map database")
("climate-signal,c", prog_opt::value<std::string>(&climate_signal)->default_value("1"), "The climate change projection that should be used")
("portfolio-signal,p", prog_opt::value<std::vector<std::string> >(&portfolio_signal), "The mitigation portfolios that should be used. Need to specify exactly the number of portfolios as there are catchments")
("ARI,r", prog_opt::value<int>(&ari_signal)->default_value(20), "The 1:ari value indicating expected frequency of flood hazard")
("year,y", prog_opt::value<int>(&year)->default_value(2015), "specify year in which to calculate flood hazard for")
("output,o", prog_opt::value<std::string>(&output_path_str)->default_value("output.tif"), "The path to print output interpolated map to")
("int-signam,i", prog_opt::value<bool>(&use_int_signals)->default_value(true), "Whether to use string or int representation of mitigation and climate scanario signals");
prog_opt::positional_options_description p;
p.add("portfolio-signal", -1);
prog_opt::variables_map vm;
prog_opt::store(prog_opt::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
prog_opt::notify(vm);
if (vm.count("help"))
{
std::cout << desc << "\n";
return 1;
}
if (vm.count("portfolio-signal"))
{
std::cout << "Mitigation portfolios are: "
<< vm["portfolio-signal"].as< std::vector<std::string> >() << "\n";
}
file_sys::path base_dir(base_dir_str);
//Check if base directory exists
if (!file_sys::exists(base_dir))
{
std::cerr << "Base directory of database does not exist" << std::endl;
//Could throw an error here instead
}
Database my_data;
processDatabase(my_data, base_dir);
//Read in template map.
fs::path template_map = base_dir / "template.tif";
std::tuple<Map_Double_SPtr, std::string, GeoTransform> gdal_map = read_in_map<double>(template_map, GDT_Float64, NO_CATEGORISATION);
Map_Double_SPtr map(std::get<0>(gdal_map));
std::string & map_WKT_projection = (std::get<1>(gdal_map));
GeoTransform & map_transform = (std::get<2>(gdal_map));
int nrows = map->NRows();
int ncols = map->NCols();
double no_data_val = map->NoDataValue();
//Set number of mitigaiton portfolios and scenarios
int num_of_scenarios = my_data.get_catchment(1)->clim_scnrios_ik.size();
int num_of_portfolios = my_data.get_catchment(1)->get_scenario(1)->mit_prtflios_ik.size();
StitchedMapSet maps;
if (use_int_signals == true)
{
std::vector<int> portfolios;
for (int i = 0; i < num_of_portfolios; ++i)
{
portfolios[i] = std::stoi(portfolio_signal[i]);
}
int scenario = std::stoi(climate_signal);
getMapSet(climate_signal, portfolio_signal, my_data, maps, ncols, nrows, no_data_val);
}
else
{
getMapSet(climate_signal, portfolio_signal, my_data, maps, ncols, nrows, no_data_val);
}
Map_Float_SPtr interped_map = interpolatedmap(ari_signal, year, maps);
/********************************************/
/* Print resultent map */
/********************************************/
//Open template map to get projection and transformation information.
file_sys::path template_path = base_dir / "template.tif";
std::string wKTprojection;
GeoTransform transform;
Map_Float_SPtr template_map;
std::tie(template_map, wKTprojection, transform) = read_in_map<float>(template_path, GDT_Float32, NO_CATEGORISATION);
file_sys::path output_path(output_path_str);
std::cout << "\n\n*************************************\n";
std::cout << "* Saving output file *\n";
std::cout << "*************************************" << std::endl;
std::string driverName = "GTiff";
write_map(output_path, GDT_Float32, interped_map, wKTprojection, transform, driverName);
std::cout << "finished processing database" << std::endl;
std::cout << "Another breakpoint" << std::endl;
}
static int write_datum(avro_writer_t writer, const avro_encoding_t * enc,
avro_schema_t writers_schema, avro_datum_t datum)
{
if (is_avro_schema(writers_schema) && is_avro_link(writers_schema)) {
return write_datum(writer, enc,
(avro_schema_to_link(writers_schema))->to,
datum);
}
switch (avro_typeof(datum)) {
case AVRO_NULL:
return enc->write_null(writer);
case AVRO_BOOLEAN:
return enc->write_boolean(writer,
avro_datum_to_boolean(datum)->i);
case AVRO_STRING:
return enc->write_string(writer,
avro_datum_to_string(datum)->s);
case AVRO_BYTES:
return enc->write_bytes(writer,
avro_datum_to_bytes(datum)->bytes,
avro_datum_to_bytes(datum)->size);
case AVRO_INT32:
case AVRO_INT64:{
int64_t val = avro_typeof(datum) == AVRO_INT32 ?
avro_datum_to_int32(datum)->i32 :
avro_datum_to_int64(datum)->i64;
if (is_avro_schema(writers_schema)) {
/* handle promotion */
if (is_avro_float(writers_schema)) {
return enc->write_float(writer,
(float)val);
} else if (is_avro_double(writers_schema)) {
return enc->write_double(writer,
(double)val);
}
}
return enc->write_long(writer, val);
}
case AVRO_FLOAT:{
float val = avro_datum_to_float(datum)->f;
if (is_avro_schema(writers_schema)
&& is_avro_double(writers_schema)) {
/* handle promotion */
return enc->write_double(writer, (double)val);
}
return enc->write_float(writer, val);
}
case AVRO_DOUBLE:
return enc->write_double(writer,
avro_datum_to_double(datum)->d);
case AVRO_RECORD:
return write_record(writer, enc,
avro_schema_to_record(writers_schema),
datum);
case AVRO_ENUM:
return write_enum(writer, enc,
avro_schema_to_enum(writers_schema),
avro_datum_to_enum(datum));
case AVRO_FIXED:
return avro_write(writer,
avro_datum_to_fixed(datum)->bytes,
avro_datum_to_fixed(datum)->size);
case AVRO_MAP:
return write_map(writer, enc,
avro_schema_to_map(writers_schema),
avro_datum_to_map(datum));
case AVRO_ARRAY:
return write_array(writer, enc,
avro_schema_to_array(writers_schema),
avro_datum_to_array(datum));
case AVRO_UNION:
return write_union(writer, enc,
avro_schema_to_union(writers_schema),
avro_datum_to_union(datum));
case AVRO_LINK:
break;
}
return 0;
}
int map_read_line(const char **s)
{
const char *id;
if ( is_inside_proc != 0 )
{
if ( uglReadLine(s) == 0 )
is_inside_proc = 0;
return 1;
}
skip_space(s);
if ( **s == '#' ) /* comment (hmm handled by skip_space) */
return 1;
if ( **s == '\0' ) /* empty line */
return 1;
if ( **s == ':' )
{
(*s)++;
return map_read_row(s);
}
id = get_identifier(s);
if ( strcmp(id, "tile") == 0 )
{
return map_read_tile(s, 0, -1);
}
else if ( strcmp(id, "thing") == 0 )
{
return map_read_tile(s, 1, -1);
}
else if ( strcmp(id, "itemkey") == 0 )
{
const char *id;
int idx;
id = get_identifier(s);
idx = item_get_idx_by_name(id);
if ( idx < 0 )
{
printf("code line %d, item '%s' unknown.\n", ugl_current_input_line, id);
}
else
{
return map_read_tile(s, 1, idx);
}
}
else if ( strcmp(id, "item") == 0 )
{
const char *id;
int idx;
id = get_identifier(s);
idx = item_get_idx_by_name(id);
if ( idx >= 0 )
{
printf("code line %d, item '%s' already exists.\n", ugl_current_input_line, id);
}
else
{
if ( item_add(id) < 0 )
{
printf("code line %d, item '%s': Too many items.\n", ugl_current_input_line, id);
}
else
{
idx = item_get_idx_by_name(id);
assert( idx >= 0 );
item_list[idx].fg_tile = get_num(s);
}
}
return 1;
}
else if ( strcmp(id, "mapinit") == 0 )
{
map_init_code_pos = uglStartNamelessProc(0);
is_inside_proc = 1;
return 1;
}
else if ( strcmp(id, "iteminit") == 0 )
{
const char *id;
int idx;
uint16_t code_pos;
id = get_identifier(s);
idx = item_get_idx_by_name(id);
code_pos = uglStartNamelessProc(0);
if ( idx < 0 )
{
printf("code line %d, item '%s' not found.\n", ugl_current_input_line, id);
}
else
{
item_list[idx].init_proc= code_pos;
}
is_inside_proc = 1;
return 1;
}
else if ( strcmp(id, "itemhit") == 0 )
{
const char *id;
int idx;
uint16_t code_pos;
id = get_identifier(s);
idx = item_get_idx_by_name(id);
code_pos = uglStartNamelessProc(0);
if ( idx < 0 )
{
printf("code line %d, item '%s' not found.\n", ugl_current_input_line, id);
}
else
{
item_list[idx].hit_proc= code_pos;
}
is_inside_proc = 1;
return 1;
}
else if ( strcmp(id, "itemstep") == 0 )
{
const char *id;
int idx;
uint16_t code_pos;
id = get_identifier(s);
idx = item_get_idx_by_name(id);
code_pos = uglStartNamelessProc(0);
if ( idx < 0 )
{
printf("code line %d, item '%s' not found.\n", ugl_current_input_line, id);
}
else
{
item_list[idx].step_proc= code_pos;
}
is_inside_proc = 1;
return 1;
}
else if ( strcmp(id, "map") == 0 )
{
is_inside_map = 1;
return map_read_map_cmd(s);
}
else if ( strcmp(id, "endmap") == 0 )
{
/* write existing map: once a map has been read, transform it to the target */
if ( map_width > 0 && map_height > 0 )
{
if ( map_all_tiles() )
{
char buf[128];
write_map();
write_item_onmap();
sprintf(buf, "%s.tga", map_name);
write_tga_map(buf);
write_map_struct();
}
}
is_inside_map = 0;
return 1;
}
else
{
printf("code line %d, map line %d: unkown command '%s'\n", ugl_current_input_line, map_curr_line, id);
}
return 1;
}
int main(int argc, char **argv)
{
/**********************************/
/* Program options */
/**********************************/
// Need to specify elevation grid
// Need to specify channel
// std::string feature_file;
std::string dem_file;
std::string guage_file("no_file");
// std::string changes_file;
// std::string log_file;
// std::string fd_file;
std::string hydro_paths_file;
std::string output_file;
std::string channel_graph_file;
std::string controls_file("no_file");
// bool do_print = false;
// std::string file_print;
// unsigned int trim_level;
bool do_interp_hgl = true;
bool write_controls= false;
double outflow_levels = 1.0;
double source_levels = 0.0;
bool use_controls_file = false;
namespace prog_opt = boost::program_options;
prog_opt::options_description desc("Allowed options");
desc.add_options()
("help,h", "produce help message")
// ("feature-map,f", prog_opt::value<std::string>(&feature_file), "path of the gdal capatible raster feature file")
("dem-map,d", prog_opt::value<std::string>(&dem_file), "path of the gdal capatible elevation data file")
// ("flow-dir-map,i", prog_opt::value<std::string>(&fd_file), "path of the gdal capatible flow direction data file")
("hydro-paths-file,p", prog_opt::value<std::string>(&hydro_paths_file)->default_value("hydro-paths.tif"), "path of the output map where each pixel is assigned the location on channel that the pixel is hydrologically connected to ")
("channel-graph,g", prog_opt::value<std::string>(&channel_graph_file), "path of the graphml representation of the channel")
("guage-table,t", prog_opt::value<std::string>(&guage_file), "path of text file with guage location and levels, takes precedence over channel graph")
("output-flood-height-file,o", prog_opt::value<std::string>(&output_file)->default_value("flood_height.tif"), "path of the output map where each pixel is assigned the flood height at that pixel")
// ("trim-branches,t", prog_opt::value<unsigned int>(&trim_level)->default_value(0), "remove branches if they are composed with a number of pixels less than this amount")
("interp-hgl,n", prog_opt::value<bool>(&do_interp_hgl)->default_value(true), "True for interpolation based on hgl, false if based on water column depth")
("write-controls,w", prog_opt::value<bool>(&write_controls)->default_value(false), "Write list of control nodes to file")
("read-controls,r", prog_opt::value<std::string>(&controls_file), "Name of controls file to read into. Take precedence over guage table file")
("outflow-levels,u", prog_opt::value<double>(&outflow_levels), "Flood level assigned to outflow nodes (least precedence)")
("source-levels,s", prog_opt::value<double>(&source_levels), "Flood level assigned to outflow nodes (least precedence)");
// ("log_file,l", prog_opt::value<std::string>(&log_file)->default_value("moves.log"), "path of the file which logs feature cell movements")
// ("print,p", prog_opt::value<std::string>(&file_print), "Print map to text file (space seperated values) - specify file name prefix");
prog_opt::variables_map vm;
prog_opt::store(prog_opt::parse_command_line(argc, argv, desc), vm);
prog_opt::notify(vm);
if (vm.count("help"))
{
std::cout << desc << "\n";
return 1;
}
if (vm.count("read-controls"))
{
use_controls_file = true;
}
// if (vm.count("print"))
// {
// do_print = true;
// }
fs::path channel_graph_path(channel_graph_file);
fs::path dem_file_path(dem_file);
// fs::path changes_file_path(changes_file);
fs::path guage_table_path(guage_file);
// fs::path fd_file_path(fd_file);
fs::path hydro_paths_file_path(hydro_paths_file);
fs::path output_file_path(output_file);
/********************************************/
/* Print resultent DEM */
/********************************************/
std::cout << "\n\n*************************************\n";
std::cout << "* Saving output file *\n";
std::cout << "*************************************" << std::endl;
std::string driverName = "GTiff";
write_map(output_file_path, GDT_Float64, output_map, demWKTprojection, demTransform, driverName);
return (EXIT_SUCCESS);
// double no_changes_val = 0.0;
// if (dem_map->HasNoDataValue()) no_changes_val = dem_map->NoDataValue();
// Map_Double_SPtr changes_map(new Map_Double(feature_map->NRows(), feature_map->NCols(), no_changes_val));
// changes_map->SetNoDataValue(no_changes_val);
// boost::progress_display show_progress3(boost::num_vertices(channel_grph));
// dfs_interpolate_visitor vis(dem_map, changes_map, show_progress3);
// boost::depth_first_search(channel_grph, visitor(vis));
/********************************************/
/* //Create map of downstream control IDs, upstream control IDs, Distance to downstram and upstream IDs */
/********************************************/
// std::string driverName = "GTiff";
// write_map(incised_dem_file_path, GDT_Float64, dem_map, demWKTprojection, demTransform, driverName);
// write_map(changes_file_path, GDT_Float64, changes_map, demWKTprojection, demTransform, driverName);
}
pdf_obj *
CMap_create_stream (CMap *cmap)
{
pdf_obj *stream;
pdf_obj *stream_dict;
CIDSysInfo *csi;
struct sbuf wbuf;
struct rangeDef *ranges;
unsigned char *codestr;
int i, j, count = 0;
if (!cmap || !CMap_is_valid(cmap)) {
WARN("Invalid CMap");
return NULL;
}
if (cmap->type == CMAP_TYPE_IDENTITY)
return NULL;
stream = pdf_new_stream(STREAM_COMPRESS);
stream_dict = pdf_stream_dict(stream);
csi = CMap_get_CIDSysInfo(cmap);
if (!csi) {
csi = (cmap->type != CMAP_TYPE_TO_UNICODE) ?
&CSI_IDENTITY : &CSI_UNICODE;
}
if (cmap->type != CMAP_TYPE_TO_UNICODE) {
pdf_obj *csi_dict;
csi_dict = pdf_new_dict();
pdf_add_dict(csi_dict,
pdf_new_name("Registry"),
pdf_new_string(csi->registry, strlen(csi->registry)));
pdf_add_dict(csi_dict,
pdf_new_name("Ordering"),
pdf_new_string(csi->ordering, strlen(csi->ordering)));
pdf_add_dict(csi_dict,
pdf_new_name("Supplement"),
pdf_new_number(csi->supplement));
pdf_add_dict(stream_dict,
pdf_new_name("Type"),
pdf_new_name("CMap"));
pdf_add_dict(stream_dict,
pdf_new_name("CMapName"),
pdf_new_name(cmap->name));
pdf_add_dict(stream_dict,
pdf_new_name("CIDSystemInfo"), csi_dict);
if (cmap->wmode != 0)
pdf_add_dict(stream_dict,
pdf_new_name("WMode"),
pdf_new_number(cmap->wmode));
}
/* TODO:
* Predefined CMaps need not to be embedded.
*/
if (cmap->useCMap) {
ERROR("UseCMap found (not supported yet)...");
if (CMap_is_Identity(cmap->useCMap)) { /* not sure */
if (CMap_get_wmode(cmap) == 1) {
pdf_add_dict(stream_dict,
pdf_new_name("UseCMap"),
pdf_new_name("Identity-V"));
} else {
pdf_add_dict(stream_dict,
pdf_new_name("UseCMap"),
pdf_new_name("Identity-H"));
}
} else {
int res_id;
pdf_obj *ucmap_ref;
res_id = pdf_findresource("CMap", CMap_get_name(cmap->useCMap));
if (res_id >= 0) {
ucmap_ref = pdf_get_resource_reference(res_id);
} else {
pdf_obj *ucmap_obj;
ucmap_obj = CMap_create_stream(cmap->useCMap);
if (!ucmap_obj) {
ERROR("Uh ah. I cannot continue...");
}
res_id = pdf_defineresource("CMap",
CMap_get_name(cmap->useCMap),
ucmap_obj, PDF_RES_FLUSH_IMMEDIATE);
ucmap_ref = pdf_get_resource_reference(res_id);
}
pdf_add_dict(stream_dict, pdf_new_name("UseCMap"), ucmap_ref);
}
}
#define WBUF_SIZE 40960
wbuf.buf = NEW(WBUF_SIZE, char);
codestr = NEW(cmap->profile.maxBytesIn, unsigned char);
memset(codestr, 0, cmap->profile.maxBytesIn);
wbuf.curptr = wbuf.buf;
wbuf.limptr = wbuf.buf + WBUF_SIZE -
2 * (cmap->profile.maxBytesIn + cmap->profile.maxBytesOut) + 16;
/* Start CMap */
pdf_add_stream(stream, (const void *) CMAP_BEGIN, strlen(CMAP_BEGIN));
wbuf.curptr += sprintf(wbuf.curptr, "/CMapName ");
write_name(&wbuf.curptr, wbuf.limptr, cmap->name);
wbuf.curptr += sprintf(wbuf.curptr, " def\n");
wbuf.curptr += sprintf(wbuf.curptr, "/CMapType %d def\n" , cmap->type);
if (cmap->wmode != 0 &&
cmap->type != CMAP_TYPE_TO_UNICODE)
wbuf.curptr += sprintf(wbuf.curptr, "/WMode %d def\n", cmap->wmode);
#define CMAP_CSI_FMT "/CIDSystemInfo <<\n\
/Registry (%s)\n\
/Ordering (%s)\n\
/Supplement %d\n\
>> def\n"
wbuf.curptr += sprintf(wbuf.curptr, "/CIDSystemInfo <<\n");
wbuf.curptr += sprintf(wbuf.curptr, " /Registry ");
write_string(&wbuf.curptr, wbuf.limptr, csi->registry);
wbuf.curptr += sprintf(wbuf.curptr, "\n");
wbuf.curptr += sprintf(wbuf.curptr, " /Ordering ");
write_string(&wbuf.curptr, wbuf.limptr, csi->ordering);
wbuf.curptr += sprintf(wbuf.curptr, "\n");
wbuf.curptr += sprintf(wbuf.curptr, " /Supplement %d\n>> def\n",
csi->supplement);
pdf_add_stream(stream, wbuf.buf, (int)(wbuf.curptr - wbuf.buf));
wbuf.curptr = wbuf.buf;
/* codespacerange */
ranges = cmap->codespace.ranges;
wbuf.curptr += sprintf(wbuf.curptr,
"%d begincodespacerange\n", cmap->codespace.num);
for (i = 0; i < cmap->codespace.num; i++) {
*(wbuf.curptr)++ = '<';
for (j = 0; j < ranges[i].dim; j++) {
sputx(ranges[i].codeLo[j], &(wbuf.curptr), wbuf.limptr);
}
*(wbuf.curptr)++ = '>';
*(wbuf.curptr)++ = ' ';
*(wbuf.curptr)++ = '<';
for (j = 0; j < ranges[i].dim; j++) {
sputx(ranges[i].codeHi[j], &(wbuf.curptr), wbuf.limptr);
}
*(wbuf.curptr)++ = '>';
*(wbuf.curptr)++ = '\n';
}
pdf_add_stream(stream, wbuf.buf, (int)(wbuf.curptr - wbuf.buf));
wbuf.curptr = wbuf.buf;
pdf_add_stream(stream,
"endcodespacerange\n", strlen("endcodespacerange\n"));
/* CMap body */
if (cmap->mapTbl) {
count = write_map(cmap->mapTbl,
0, codestr, 0, &wbuf, stream); /* Top node */
if (count > 0) { /* Flush */
char fmt_buf[32];
if (count > 100)
ERROR("Unexpected error....: %d", count);
sprintf(fmt_buf, "%d beginbfchar\n", count);
pdf_add_stream(stream, fmt_buf, strlen(fmt_buf));
pdf_add_stream(stream,
wbuf.buf, (int) (wbuf.curptr - wbuf.buf));
pdf_add_stream(stream,
"endbfchar\n", strlen("endbfchar\n"));
count = 0;
wbuf.curptr = wbuf.buf;
}
}
/* End CMap */
pdf_add_stream(stream, CMAP_END, strlen(CMAP_END));
RELEASE(codestr);
RELEASE(wbuf.buf);
return stream;
}
static int
write_map (mapDef *mtab, int count,
unsigned char *codestr, int depth,
struct sbuf *wbuf, pdf_obj *stream)
{
int c, i, block_length;
mapDef *mtab1;
/* Must be greater than 1 */
#define BLOCK_LEN_MIN 2
struct {
int start, count;
} blocks[256/BLOCK_LEN_MIN+1];
int num_blocks = 0;
for (c = 0; c < 256; c++) {
codestr[depth] = (unsigned char) (c & 0xff);
if (LOOKUP_CONTINUE(mtab[c].flag)) {
mtab1 = mtab[c].next;
count = write_map(mtab1, count,
codestr, depth + 1, wbuf, stream);
} else {
if (MAP_DEFINED(mtab[c].flag)) {
switch (MAP_TYPE(mtab[c].flag)) {
case MAP_IS_CID: case MAP_IS_CODE:
block_length = block_count(mtab, c);
if (block_length >= BLOCK_LEN_MIN) {
blocks[num_blocks].start = c;
blocks[num_blocks].count = block_length;
num_blocks++;
c += block_length;
} else {
*(wbuf->curptr)++ = '<';
for (i = 0; i <= depth; i++)
sputx(codestr[i], &(wbuf->curptr), wbuf->limptr);
*(wbuf->curptr)++ = '>';
*(wbuf->curptr)++ = ' ';
*(wbuf->curptr)++ = '<';
for (i = 0; i < mtab[c].len; i++)
sputx(mtab[c].code[i], &(wbuf->curptr), wbuf->limptr);
*(wbuf->curptr)++ = '>';
*(wbuf->curptr)++ = '\n';
count++;
}
break;
case MAP_IS_NAME:
ERROR("%s: Unexpected error...", CMAP_DEBUG_STR);
break;
case MAP_IS_NOTDEF:
break;
default:
ERROR("%s: Unknown mapping type: %d",
CMAP_DEBUG_STR, MAP_TYPE(mtab[c].flag));
}
}
}
/* Flush if necessary */
if (count >= 100 ||
wbuf->curptr >= wbuf->limptr ) {
char fmt_buf[32];
if (count > 100)
ERROR("Unexpected error....: %d", count);
sprintf(fmt_buf, "%d beginbfchar\n", count);
pdf_add_stream(stream, fmt_buf, strlen(fmt_buf));
pdf_add_stream(stream,
wbuf->buf, (int) (wbuf->curptr - wbuf->buf));
wbuf->curptr = wbuf->buf;
pdf_add_stream(stream,
"endbfchar\n", strlen("endbfchar\n"));
count = 0;
}
}
if (num_blocks > 0) {
char fmt_buf[32];
if (count > 0) {
sprintf(fmt_buf, "%d beginbfchar\n", count);
pdf_add_stream(stream, fmt_buf, strlen(fmt_buf));
pdf_add_stream(stream,
wbuf->buf, (int) (wbuf->curptr - wbuf->buf));
wbuf->curptr = wbuf->buf;
pdf_add_stream(stream,
"endbfchar\n", strlen("endbfchar\n"));
count = 0;
}
sprintf(fmt_buf, "%d beginbfrange\n", num_blocks);
pdf_add_stream(stream, fmt_buf, strlen(fmt_buf));
for (i = 0; i < num_blocks; i++) {
int j;
c = blocks[i].start;
*(wbuf->curptr)++ = '<';
for (j = 0; j < depth; j++)
sputx(codestr[j], &(wbuf->curptr), wbuf->limptr);
sputx((unsigned char)c, &(wbuf->curptr), wbuf->limptr);
*(wbuf->curptr)++ = '>';
*(wbuf->curptr)++ = ' ';
*(wbuf->curptr)++ = '<';
for (j = 0; j < depth; j++)
sputx(codestr[j], &(wbuf->curptr), wbuf->limptr);
sputx((unsigned char)(c + blocks[i].count), &(wbuf->curptr), wbuf->limptr);
*(wbuf->curptr)++ = '>';
*(wbuf->curptr)++ = ' ';
*(wbuf->curptr)++ = '<';
for (j = 0; j < mtab[c].len; j++)
sputx(mtab[c].code[j], &(wbuf->curptr), wbuf->limptr);
*(wbuf->curptr)++ = '>';
*(wbuf->curptr)++ = '\n';
}
pdf_add_stream(stream,
wbuf->buf, (int) (wbuf->curptr - wbuf->buf));
wbuf->curptr = wbuf->buf;
pdf_add_stream(stream,
"endbfrange\n", strlen("endbfrange\n"));
}
return count;
}
