void wrentity(PAD_ENT_HDR adenhd, PAD_ENT aden, int level, AD_VMADDR entlist,
int circle_as_point)
{
short ret;
PAD_BLOB_CTRL bcptr;
PAD_ENT_HDR adenhd2;
PAD_ENT aden2;
OdaLong il;
double tempdouble[2], tempbulge, tempwidth[2];
double x, y, z, ang;
PAD_BLKH adblkh;
int layer_found = 1;
if (is_low_level(adenhd))
n_elements++;
/* Check layer name */
if (layers_opt->answers) {
int i = 0;
adSeekLayer(dwghandle, adenhd->entlayerobjhandle, Layer);
layer_found = 0;
if (!Layer->purgedflag) {
while (layers_opt->answers[i]) {
if (strcmp(Layer->name, layers_opt->answers[i]) == 0) {
layer_found = 1;
break;
}
i++;
}
}
if ((!invert_flag->answer && !layer_found) ||
(invert_flag->answer && layer_found)) {
if (is_low_level(adenhd))
n_skipped++;
if (adenhd->enttype != AD_ENT_INSERT &&
adenhd->enttype != AD_ENT_POLYLINE)
return;
}
}
getEntTypeName(adenhd, buf);
G_debug(1, "Entity: %s", buf);
Txt = NULL;
adenhd2 = (PAD_ENT_HDR) G_malloc(sizeof(AD_ENT_HDR));
aden2 = (PAD_ENT) G_malloc(sizeof(AD_ENT));
adblkh = (PAD_BLKH) G_malloc(sizeof(AD_BLKH));
Vect_reset_line(Points);
/* Check space for lower level */
if (level + 1 == atrans) {
atrans += 10;
Trans = (TRANS *) G_realloc(Trans, atrans * sizeof(TRANS));
}
switch (adenhd->enttype) {
case AD_ENT_LINE:
Vect_append_point(Points, aden->line.pt0[0], aden->line.pt0[1],
aden->line.pt0[2]);
Vect_append_point(Points, aden->line.pt1[0], aden->line.pt1[1],
aden->line.pt1[2]);
write_line(adenhd, GV_LINE, level);
break;
case AD_ENT_FACE3D:
Vect_append_point(Points, aden->face3d.pt0[0], aden->face3d.pt0[1],
aden->face3d.pt0[2]);
Vect_append_point(Points, aden->face3d.pt1[0], aden->face3d.pt1[1],
aden->face3d.pt1[2]);
Vect_append_point(Points, aden->face3d.pt2[0], aden->face3d.pt2[1],
aden->face3d.pt2[2]);
Vect_append_point(Points, aden->face3d.pt3[0], aden->face3d.pt3[1],
aden->face3d.pt3[2]);
write_line(adenhd, GV_FACE, level);
break;
case AD_ENT_SOLID:
Vect_append_point(Points, aden->solid.pt0[0], aden->solid.pt0[1],
aden->solid.pt0[2]);
Vect_append_point(Points, aden->solid.pt1[0], aden->solid.pt1[1],
aden->solid.pt1[2]);
Vect_append_point(Points, aden->solid.pt2[0], aden->solid.pt2[1],
aden->solid.pt2[2]);
Vect_append_point(Points, aden->solid.pt3[0], aden->solid.pt3[1],
aden->solid.pt3[2]);
write_line(adenhd, GV_FACE, level);
break;
case AD_ENT_TEXT:
Txt = aden->text.textstr;
Vect_append_point(Points, aden->text.pt0[0], aden->text.pt0[1],
aden->line.pt0[2]);
write_line(adenhd, GV_POINT, level);
break;
case AD_ENT_POINT:
Vect_append_point(Points, aden->point.pt0[0], aden->point.pt0[1],
aden->line.pt0[2]);
write_line(adenhd, GV_POINT, level);
break;
case AD_ENT_ARC:
for (ang = aden->arc.stang; ang < aden->arc.endang;
ang += 2 * LOCPI / 360) {
x = aden->arc.pt0[0] + aden->arc.radius * cos(ang);
y = aden->arc.pt0[1] + aden->arc.radius * sin(ang);
z = aden->arc.pt0[2];
Vect_append_point(Points, x, y, z);
}
x = aden->arc.pt0[0] + aden->arc.radius * cos(aden->arc.endang);
y = aden->arc.pt0[1] + aden->arc.radius * sin(aden->arc.endang);
z = aden->arc.pt0[2];
Vect_append_point(Points, x, y, z);
write_line(adenhd, GV_LINE, level);
break;
case AD_ENT_CIRCLE:
if (circle_as_point) {
Vect_append_point(Points, aden->circle.pt0[0],
aden->circle.pt0[1], aden->circle.pt0[3]);
write_line(adenhd, GV_POINT, level);
}
else {
for (ang = 0; ang < 2 * LOCPI; ang += 2 * LOCPI / 360) {
x = aden->circle.pt0[0] + aden->circle.radius * cos(ang);
y = aden->circle.pt0[1] + aden->circle.radius * sin(ang);
z = aden->circle.pt0[3];
Vect_append_point(Points, x, y, z);
}
Vect_append_point(Points, Points->x[0], Points->y[0],
Points->z[0]);
write_line(adenhd, GV_LINE, level);
}
break;
/* BLOCK starts block of entities but makes no transformation - is it right ?
* -> do nothing just warn for xref */
case AD_ENT_BLOCK:
if (aden->block.xrefpath[0]) {
G_warning
("External reference for block not supported.\n xref: %s",
aden->block.xrefpath);
}
Block = G_store(aden->block.name2);
break;
case AD_ENT_ENDBLK: /* endblk - no data */
G_free(Block);
Block = NULL;
break;
case AD_ENT_INSERT: /* insert */
/* get transformation */
/* TODO: fix rotation for CIRCLE and ARC */
G_debug(3, " x,y,z: %f, %f, %f", aden->insert.pt0[0],
aden->insert.pt0[1], aden->insert.pt0[2]);
G_debug(3, " xscale, yscale, zscale: %f, %f, %f", aden->insert.xscale,
aden->insert.yscale, aden->insert.zscale);
G_debug(3, " rotang: %f", aden->insert.rotang);
G_debug(3, " ncols, nrows: %d, %d", aden->insert.numcols,
aden->insert.numrows);
G_debug(3, " coldist, rowdist: %f, %f", aden->insert.coldist,
aden->insert.rowdist);
/* write block entities */
adSeekBlockheader(dwghandle, aden->insert.blockheaderobjhandle,
adblkh);
if (!adblkh->purgedflag) {
adStartEntityGet(adblkh->entitylist);
while (1) {
ret = adGetEntity(adblkh->entitylist, adenhd2, aden2);
if (adenhd2->enttype == AD_ENT_ENDBLK)
break;
if (ret) {
/* Set transformation for lower level */
Trans[level + 1].dx = aden->insert.pt0[0];
Trans[level + 1].dy = aden->insert.pt0[1];
Trans[level + 1].dz = aden->insert.pt0[2];
Trans[level + 1].xscale = aden->insert.xscale;
Trans[level + 1].yscale = aden->insert.yscale;
Trans[level + 1].zscale = aden->insert.zscale;
Trans[level + 1].rotang = aden->insert.rotang;
wrentity(adenhd2, aden2, level + 1, adblkh->entitylist,
circle_as_point);
}
}
}
break;
case AD_ENT_SEQEND: /* seqend */
break;
case AD_ENT_POLYLINE:
while (1) {
ret = adGetEntity(entlist, adenhd2, aden2);
if (ret != 1) {
G_warning("Cannot get entity: %d: %s.", adError(),
adErrorStr(adError()));
break;
}
if (adenhd2->enttype == AD_ENT_SEQEND)
break;
if (adenhd2->enttype != AD_ENT_VERTEX) {
getEntTypeName(adenhd2, buf);
G_warning("Expected VERTEX got %s in POLYLINE -> skip", buf);
}
else {
Vect_append_point(Points, aden2->vertex.pt0[0],
aden2->vertex.pt0[1], aden2->vertex.pt0[2]);
}
};
if ((!invert_flag->answer && layer_found) ||
(invert_flag->answer && !layer_found))
write_line(adenhd, GV_LINE, level);
break;
default:
if (adenhd->enttype == adLwplineEnttype(dwghandle)) {
G_debug(3, "Npoints: %ld\n", aden->lwpline.numpoints);
bcptr = adStartBlobRead(aden->lwpline.ldblob);
for (il = 0; il < aden->lwpline.numpoints; il++) {
adReadBlob2Double(bcptr, tempdouble);
Vect_append_point(Points, tempdouble[0], tempdouble[1],
tempdouble[2]);
tempbulge = tempwidth[0] = tempwidth[1] = tempwidth[2] = 0.0;
if (aden->lwpline.flag & AD_LWPLINE_HAS_BULGES) {
adReadBlobDouble(bcptr, &tempbulge);
}
if (aden->lwpline.flag & AD_LWPLINE_HAS_WIDTHS) {
adReadBlob2Double(bcptr, tempwidth);
}
}
G_debug(3, "flag = %d", aden->lwpline.flag);
if (aden->lwpline.flag & AD_LWPLINE_IS_CLOSED) {
G_debug(3, " -> is closed");
Vect_append_point(Points, Points->x[0], Points->y[0],
Points->z[0]);
}
write_line(adenhd, GV_LINE, level);
adEndBlobRead(bcptr);
}
else {
getEntTypeName(adenhd, buf);
G_warning("%s entity not supported", buf);
}
break;
} /* end of switch */
G_free(aden2);
G_free(adenhd2);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *out_opt, *in_opt;
struct Flag *z_flag, *circle_flag, *l_flag, *int_flag;
char buf[2000];
/* DWG */
char path[2000];
short initerror, entset, retval;
AD_OBJHANDLE pspace, mspace;
PAD_ENT_HDR adenhd;
PAD_ENT aden;
AD_VMADDR entlist;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("import"));
module->description = _("Converts DWG/DXF to GRASS vector map");
in_opt = G_define_standard_option(G_OPT_F_INPUT);
in_opt->description = _("Name of DWG or DXF file");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
out_opt->required = YES;
layers_opt = G_define_option();
layers_opt->key = "layers";
layers_opt->type = TYPE_STRING;
layers_opt->required = NO;
layers_opt->multiple = YES;
layers_opt->description = _("List of layers to import");
invert_flag = G_define_flag();
invert_flag->key = 'i';
invert_flag->description =
_("Invert selection by layers (don't import layers in list)");
z_flag = G_define_flag();
z_flag->key = 'z';
z_flag->description = _("Create 3D vector map");
circle_flag = G_define_flag();
circle_flag->key = 'c';
circle_flag->description = _("Write circles as points (centre)");
l_flag = G_define_flag();
l_flag->key = 'l';
l_flag->description = _("List available layers and exit");
int_flag = G_define_flag();
int_flag->key = 'n';
int_flag->description = _("Use numeric type for attribute \"layer\"");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
db_init_string(&sql);
db_init_string(&str);
adenhd = (PAD_ENT_HDR) G_malloc(sizeof(AD_ENT_HDR));
aden = (PAD_ENT) G_malloc(sizeof(AD_ENT));
Layer = (PAD_LAY) G_malloc(sizeof(AD_LAY));
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Block = NULL;
atrans = 20; /* nested, recursive levels */
Trans = (TRANS *) G_malloc(atrans * sizeof(TRANS));
/* Init OpenDWG */
sprintf(path, "%s/etc/adinit.dat", G_gisbase());
if (!adInitAd2(path, &initerror)) {
sprintf(buf, _("Unable to initialize OpenDWG Toolkit, error: %d: %s."),
initerror, adErrorStr(initerror));
if (initerror == AD_UNABLE_TO_OPEN_INIT_FILE)
sprintf(buf, _("%s Cannot open %s"), buf, path);
G_fatal_error(buf);
}
adSetupDwgRead();
adSetupDxfRead();
/* Open input file */
if ((dwghandle = adLoadFile(in_opt->answer, AD_PRELOAD_ALL, 1)) == NULL) {
G_fatal_error(_("Unable to open input file <%s>. Error %d: %s"),
in_opt->answer, adError(),
adErrorStr(adError()));
}
if (l_flag->answer) { /* List layers */
PAD_TB adtb;
AD_DWGHDR adhd;
int i;
char on, frozen, vpfrozen, locked;
adtb = (PAD_TB) G_malloc(sizeof(AD_TB));
G_debug(2, "%d layers", (int)adNumLayers(dwghandle));
adReadHeaderBlock(dwghandle, &adhd);
adStartLayerGet(dwghandle);
fprintf(stdout, "%d layers:\n", (int)adNumLayers(dwghandle));
for (i = 0; i < (int)adNumLayers(dwghandle); i++) {
adGetLayer(dwghandle, &(adtb->lay));
if (!adtb->lay.purgedflag) {
fprintf(stdout, "%s COLOR %d, ", adtb->lay.name,
adtb->lay.color);
}
adGetLayerState(dwghandle, adtb->lay.objhandle, &on, &frozen,
&vpfrozen, &locked);
if (on)
fprintf(stdout, "ON, ");
else
fprintf(stdout, "OFF, ");
if (frozen)
fprintf(stdout, "FROZEN, ");
else
fprintf(stdout, "THAWED, ");
if (vpfrozen)
fprintf(stdout, "VPFROZEN, ");
else
fprintf(stdout, "VPTHAWED, ");
if (locked)
fprintf(stdout, "LOCKED\n");
else
fprintf(stdout, "UNLOCKED\n");
}
adCloseFile(dwghandle);
adCloseAd2();
exit(EXIT_SUCCESS);
}
/* open output vector */
if (Vect_open_new(&Map, out_opt->answer, z_flag->answer) < 0)
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
Vect_hist_command(&Map);
/* Add DB link */
Fi = Vect_default_field_info(&Map, 1, NULL, GV_1TABLE);
Vect_map_add_dblink(&Map, 1, NULL, Fi->table, GV_KEY_COLUMN, Fi->database,
Fi->driver);
driver =
db_start_driver_open_database(Fi->driver,
Vect_subst_var(Fi->database, &Map));
if (driver == NULL) {
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Vect_subst_var(Fi->database, &Map), Fi->driver);
}
db_set_error_handler_driver(driver);
db_begin_transaction(driver);
/* Create table */
if (int_flag->answer) { /* List layers */
sprintf(buf,
"create table %s ( cat integer, entity_name varchar(20), color int, weight int, "
"layer real, block varchar(100), txt varchar(100) )",
Fi->table);
}
else {
sprintf(buf,
"create table %s ( cat integer, entity_name varchar(20), color int, weight int, "
"layer varchar(100), block varchar(100), txt varchar(100) )",
Fi->table);
}
db_set_string(&sql, buf);
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
db_close_database(driver);
db_shutdown_driver(driver);
G_fatal_error(_("Unable to create table: '%s'"), db_get_string(&sql));
}
if (db_create_index2(driver, Fi->table, GV_KEY_COLUMN) != DB_OK)
G_warning(_("Unable to create index for table <%s>, key <%s>"),
Fi->table, GV_KEY_COLUMN);
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT, DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Unable to grant privileges on table <%s>"),
Fi->table);
cat = 1;
n_elements = n_skipped = 0;
/* Write each entity. Some entities may be composed by other entities (like INSERT or BLOCK) */
/* Set transformation for first (index 0) level */
Trans[0].dx = Trans[0].dy = Trans[0].dz = 0;
Trans[0].xscale = Trans[0].yscale = Trans[0].zscale = 1;
Trans[0].rotang = 0;
if (adGetBlockHandle(dwghandle, pspace, AD_PAPERSPACE_HANDLE)) {
entlist = adEntityList(dwghandle, pspace);
adStartEntityGet(entlist);
for (entset = 0; entset < 2; entset++) {
do {
if (!(retval = adGetEntity(entlist, adenhd, aden)))
continue;
wrentity(adenhd, aden, 0, entlist, circle_flag->answer);
} while (retval == 1);
if (entset == 0) {
if (adGetBlockHandle(dwghandle, mspace, AD_MODELSPACE_HANDLE)) {
entlist = adEntityList(dwghandle, mspace);
adStartEntityGet(entlist);
}
}
}
}
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
adCloseFile(dwghandle);
adCloseAd2();
Vect_build(&Map, stderr);
Vect_close(&Map);
if (n_skipped > 0)
G_message(_("%d elements skipped (layer name was not in list)"),
n_skipped);
G_done_msg(_("%d elements processed"), n_elements);
exit(EXIT_SUCCESS);
}
