int DGNGetShapeFillInfo( DGNHandle hDGN, DGNElemCore *psElem, int *pnColor )
{
for( int iLink = 0; true; iLink++ )
{
int nLinkType = 0;
int nLinkSize = 0;
unsigned char *pabyData =
DGNGetLinkage( hDGN, psElem, iLink, &nLinkType,
nullptr, nullptr, &nLinkSize );
if( pabyData == nullptr )
return FALSE;
if( nLinkType == DGNLT_SHAPE_FILL && nLinkSize >= 9 )
{
*pnColor = pabyData[8];
return TRUE;
}
}
}
int DGNGetShapeFillInfo( DGNHandle hDGN, DGNElemCore *psElem, int *pnColor )
{
int iLink;
for( iLink = 0; TRUE; iLink++ )
{
int nLinkType, nLinkSize;
unsigned char *pabyData;
pabyData = DGNGetLinkage( hDGN, psElem, iLink, &nLinkType,
NULL, NULL, &nLinkSize );
if( pabyData == NULL )
return FALSE;
if( nLinkType == DGNLT_SHAPE_FILL && nLinkSize >= 7 )
{
*pnColor = pabyData[8];
return TRUE;
}
}
}
int DGNGetAssocID( DGNHandle hDGN, DGNElemCore *psElem )
{
for( int iLink = 0; true; iLink++ )
{
int nLinkType = 0;
int nLinkSize = 0;
unsigned char *pabyData =
DGNGetLinkage( hDGN, psElem, iLink, &nLinkType,
nullptr, nullptr, &nLinkSize );
if( pabyData == nullptr )
return -1;
if( nLinkType == DGNLT_ASSOC_ID && nLinkSize >= 8 )
{
return pabyData[4]
+ pabyData[5] * 256
+ pabyData[6]*256*256
+ pabyData[7] * 256*256*256;
}
}
}
int DGNGetAssocID( DGNHandle hDGN, DGNElemCore *psElem )
{
int iLink;
for( iLink = 0; TRUE; iLink++ )
{
int nLinkType, nLinkSize;
unsigned char *pabyData;
pabyData = DGNGetLinkage( hDGN, psElem, iLink, &nLinkType,
NULL, NULL, &nLinkSize );
if( pabyData == NULL )
return -1;
if( nLinkType == DGNLT_ASSOC_ID && nLinkSize >= 8 )
{
return pabyData[4]
+ pabyData[5] * 256
+ pabyData[6]*256*256
+ pabyData[7] * 256*256*256;
}
}
}
void DGNDumpElement( DGNHandle hDGN, DGNElemCore *psElement, FILE *fp )
{
DGNInfo *psInfo = (DGNInfo *) hDGN;
fprintf( fp, "\n" );
fprintf( fp, "Element:%-12s Level:%2d id:%-6d ",
DGNTypeToName( psElement->type ),
psElement->level,
psElement->element_id );
if( psElement->complex )
fprintf( fp, "(Complex) " );
if( psElement->deleted )
fprintf( fp, "(DELETED) " );
fprintf( fp, "\n" );
fprintf( fp, " offset=%d size=%d bytes\n",
psElement->offset, psElement->size );
fprintf( fp,
" graphic_group:%-3d color:%d weight:%d style:%d\n",
psElement->graphic_group,
psElement->color,
psElement->weight,
psElement->style );
if( psElement->properties != 0 )
{
int nClass;
fprintf( fp, " properties=%d", psElement->properties );
if( psElement->properties & DGNPF_HOLE )
fprintf( fp, ",HOLE" );
if( psElement->properties & DGNPF_SNAPPABLE )
fprintf( fp, ",SNAPPABLE" );
if( psElement->properties & DGNPF_PLANAR )
fprintf( fp, ",PLANAR" );
if( psElement->properties & DGNPF_ORIENTATION )
fprintf( fp, ",ORIENTATION" );
if( psElement->properties & DGNPF_ATTRIBUTES )
fprintf( fp, ",ATTRIBUTES" );
if( psElement->properties & DGNPF_MODIFIED )
fprintf( fp, ",MODIFIED" );
if( psElement->properties & DGNPF_NEW )
fprintf( fp, ",NEW" );
if( psElement->properties & DGNPF_LOCKED )
fprintf( fp, ",LOCKED" );
nClass = psElement->properties & DGNPF_CLASS;
if( nClass == DGNC_PATTERN_COMPONENT )
fprintf( fp, ",PATTERN_COMPONENT" );
else if( nClass == DGNC_CONSTRUCTION_ELEMENT )
fprintf( fp, ",CONSTRUCTION ELEMENT" );
else if( nClass == DGNC_DIMENSION_ELEMENT )
fprintf( fp, ",DIMENSION ELEMENT" );
else if( nClass == DGNC_PRIMARY_RULE_ELEMENT )
fprintf( fp, ",PRIMARY RULE ELEMENT" );
else if( nClass == DGNC_LINEAR_PATTERNED_ELEMENT )
fprintf( fp, ",LINEAR PATTERNED ELEMENT" );
else if( nClass == DGNC_CONSTRUCTION_RULE_ELEMENT )
fprintf( fp, ",CONSTRUCTION_RULE_ELEMENT" );
fprintf( fp, "\n" );
}
switch( psElement->stype )
{
case DGNST_MULTIPOINT:
{
DGNElemMultiPoint *psLine = (DGNElemMultiPoint *) psElement;
int i;
for( i=0; i < psLine->num_vertices; i++ )
fprintf( fp, " (%.6f,%.6f,%.6f)\n",
psLine->vertices[i].x,
psLine->vertices[i].y,
psLine->vertices[i].z );
}
break;
case DGNST_CELL_HEADER:
{
DGNElemCellHeader *psCell = (DGNElemCellHeader*) psElement;
fprintf( fp, " totlength=%d, name=%s, class=%x, levels=%02x%02x%02x%02x\n",
psCell->totlength, psCell->name, psCell->cclass,
psCell->levels[0], psCell->levels[1], psCell->levels[2],
psCell->levels[3] );
fprintf( fp, " rnglow=(%.5f,%.5f,%.5f)\n"
" rnghigh=(%.5f,%.5f,%.5f)\n",
psCell->rnglow.x, psCell->rnglow.y, psCell->rnglow.z,
psCell->rnghigh.x, psCell->rnghigh.y, psCell->rnghigh.z );
fprintf( fp, " origin=(%.5f,%.5f,%.5f)\n",
psCell->origin.x, psCell->origin.y, psCell->origin.z);
if( psInfo->dimension == 2 )
fprintf( fp, " xscale=%g, yscale=%g, rotation=%g\n",
psCell->xscale, psCell->yscale, psCell->rotation );
else
fprintf( fp, " trans=%g,%g,%g,%g,%g,%g,%g,%g,%g\n",
psCell->trans[0],
psCell->trans[1],
psCell->trans[2],
psCell->trans[3],
psCell->trans[4],
psCell->trans[5],
psCell->trans[6],
psCell->trans[7],
psCell->trans[8] );
}
break;
case DGNST_CELL_LIBRARY:
{
DGNElemCellLibrary *psCell = (DGNElemCellLibrary*) psElement;
fprintf( fp,
" name=%s, class=%x, levels=%02x%02x%02x%02x, numwords=%d\n",
psCell->name, psCell->cclass,
psCell->levels[0], psCell->levels[1], psCell->levels[2],
psCell->levels[3], psCell->numwords );
fprintf( fp, " dispsymb=%d, description=%s\n",
psCell->dispsymb, psCell->description );
}
break;
case DGNST_SHARED_CELL_DEFN:
{
DGNElemSharedCellDefn *psShared = (DGNElemSharedCellDefn *) psElement;
fprintf( fp, " totlength=%d\n", psShared->totlength);
}
break;
case DGNST_ARC:
{
DGNElemArc *psArc = (DGNElemArc *) psElement;
if( psInfo->dimension == 2 )
fprintf( fp, " origin=(%.5f,%.5f), rotation=%f\n",
psArc->origin.x,
psArc->origin.y,
psArc->rotation );
else
fprintf( fp, " origin=(%.5f,%.5f,%.5f), quat=%d,%d,%d,%d\n",
psArc->origin.x,
psArc->origin.y,
psArc->origin.z,
psArc->quat[0],
psArc->quat[1],
psArc->quat[2],
psArc->quat[3] );
fprintf( fp, " axes=(%.5f,%.5f), start angle=%f, sweep=%f\n",
psArc->primary_axis,
psArc->secondary_axis,
psArc->startang,
psArc->sweepang );
}
break;
case DGNST_TEXT:
{
DGNElemText *psText = (DGNElemText *) psElement;
fprintf( fp,
" origin=(%.5f,%.5f), rotation=%f\n"
" font=%d, just=%d, length_mult=%g, height_mult=%g\n"
" string = \"%s\"\n",
psText->origin.x,
psText->origin.y,
psText->rotation,
psText->font_id,
psText->justification,
psText->length_mult,
psText->height_mult,
psText->string );
}
break;
case DGNST_TEXT_NODE:
{
DGNElemTextNode *psNode = (DGNElemTextNode *) psElement;
fprintf( fp,
" totlength=%d, num_texts=%d\n",
psNode->totlength,
psNode->numelems );
fprintf( fp,
" origin=(%.5f,%.5f), rotation=%f\n"
" font=%d, just=%d, length_mult=%g, height_mult=%g\n",
psNode->origin.x,
psNode->origin.y,
psNode->rotation,
psNode->font_id,
psNode->justification,
psNode->length_mult,
psNode->height_mult );
fprintf( fp,
" max_length=%d, used=%d,",
psNode->max_length,
psNode->max_used );
fprintf( fp,
" node_number=%d\n",
psNode->node_number );
}
break;
case DGNST_COMPLEX_HEADER:
{
DGNElemComplexHeader *psHdr = (DGNElemComplexHeader *) psElement;
fprintf( fp,
" totlength=%d, numelems=%d\n",
psHdr->totlength,
psHdr->numelems );
if (psElement->type == DGNT_3DSOLID_HEADER ||
psElement->type == DGNT_3DSURFACE_HEADER) {
fprintf( fp,
" surftype=%d, boundelms=%d\n",
psHdr->surftype, psHdr->boundelms );
}
}
break;
case DGNST_COLORTABLE:
{
DGNElemColorTable *psCT = (DGNElemColorTable *) psElement;
int i;
fprintf( fp, " screen_flag: %d\n", psCT->screen_flag );
for( i = 0; i < 256; i++ )
{
fprintf( fp, " %3d: (%3d,%3d,%3d)\n",
i,
psCT->color_info[i][0],
psCT->color_info[i][1],
psCT->color_info[i][2] );
}
}
break;
case DGNST_TCB:
{
DGNElemTCB *psTCB = (DGNElemTCB *) psElement;
int iView;
fprintf( fp, " dimension = %d\n", psTCB->dimension );
fprintf( fp, " uor_per_subunit = %ld, subunits = `%s'\n",
psTCB->uor_per_subunit, psTCB->sub_units );
fprintf( fp, " subunits_per_master = %ld, master units = `%s'\n",
psTCB->subunits_per_master, psTCB->master_units );
fprintf( fp, " origin = (%.5f,%.5f,%.5f)\n",
psTCB->origin_x,
psTCB->origin_y,
psTCB->origin_z );
for( iView = 0; iView < 8; iView++ )
{
DGNViewInfo *psView = psTCB->views + iView;
fprintf(fp,
" View%d: flags=%04X, levels=%02X%02X%02X%02X%02X%02X%02X%02X\n",
iView,
psView->flags,
psView->levels[0],
psView->levels[1],
psView->levels[2],
psView->levels[3],
psView->levels[4],
psView->levels[5],
psView->levels[6],
psView->levels[7] );
fprintf(fp,
" origin=(%g,%g,%g)\n delta=(%g,%g,%g)\n",
psView->origin.x, psView->origin.y, psView->origin.z,
psView->delta.x, psView->delta.y, psView->delta.z );
fprintf(fp,
" trans=(%g,%g,%g,%g,%g,%g,%g,%g,%g)\n",
psView->transmatrx[0],
psView->transmatrx[1],
psView->transmatrx[2],
psView->transmatrx[3],
psView->transmatrx[4],
psView->transmatrx[5],
psView->transmatrx[6],
psView->transmatrx[7],
psView->transmatrx[8] );
}
}
break;
case DGNST_TAG_SET:
{
DGNElemTagSet *psTagSet = (DGNElemTagSet*) psElement;
int iTag;
fprintf( fp, " tagSetName=%s, tagSet=%d, tagCount=%d, flags=%d\n",
psTagSet->tagSetName, psTagSet->tagSet,
psTagSet->tagCount, psTagSet->flags );
for( iTag = 0; iTag < psTagSet->tagCount; iTag++ )
{
DGNTagDef *psTagDef = psTagSet->tagList + iTag;
fprintf( fp, " %d: name=%s, type=%d, prompt=%s",
psTagDef->id, psTagDef->name, psTagDef->type,
psTagDef->prompt );
if( psTagDef->type == 1 )
fprintf( fp, ", default=%s\n",
psTagDef->defaultValue.string );
else if( psTagDef->type == 3 || psTagDef->type == 5 )
fprintf( fp, ", default=%d\n",
psTagDef->defaultValue.integer );
else if( psTagDef->type == 4 )
fprintf( fp, ", default=%g\n",
psTagDef->defaultValue.real );
else
fprintf( fp, ", default=<unknown>\n" );
}
}
break;
case DGNST_TAG_VALUE:
{
DGNElemTagValue *psTag = (DGNElemTagValue*) psElement;
fprintf( fp, " tagType=%d, tagSet=%d, tagIndex=%d, tagLength=%d\n",
psTag->tagType, psTag->tagSet, psTag->tagIndex,
psTag->tagLength );
if( psTag->tagType == 1 )
fprintf( fp, " value=%s\n", psTag->tagValue.string );
else if( psTag->tagType == 3 )
fprintf( fp, " value=%d\n", psTag->tagValue.integer );
else if( psTag->tagType == 4 )
fprintf( fp, " value=%g\n", psTag->tagValue.real );
}
break;
case DGNST_CONE:
{
DGNElemCone *psCone = (DGNElemCone *) psElement;
fprintf( fp,
" center_1=(%g,%g,%g) radius=%g\n"
" center_2=(%g,%g,%g) radius=%g\n"
" quat=%d,%d,%d,%d unknown=%d\n",
psCone->center_1.x, psCone->center_1.y, psCone->center_1.z,
psCone->radius_1,
psCone->center_2.x, psCone->center_2.y, psCone->center_2.z,
psCone->radius_2,
psCone->quat[0], psCone->quat[1],
psCone->quat[2], psCone->quat[3],
psCone->unknown );
}
break;
case DGNST_BSPLINE_SURFACE_HEADER:
{
DGNElemBSplineSurfaceHeader *psSpline =
(DGNElemBSplineSurfaceHeader *) psElement;
fprintf( fp, " desc_words=%ld, curve type=%d\n",
psSpline->desc_words, psSpline->curve_type);
fprintf( fp, " U: properties=%02x",
psSpline->u_properties);
if (psSpline->u_properties != 0) {
if (psSpline->u_properties & DGNBSC_CURVE_DISPLAY) {
fprintf(fp, ",CURVE_DISPLAY");
}
if (psSpline->u_properties & DGNBSC_POLY_DISPLAY) {
fprintf(fp, ",POLY_DISPLAY");
}
if (psSpline->u_properties & DGNBSC_RATIONAL) {
fprintf(fp, ",RATIONAL");
}
if (psSpline->u_properties & DGNBSC_CLOSED) {
fprintf(fp, ",CLOSED");
}
}
fprintf(fp, "\n");
fprintf( fp, " order=%d\n %d poles, %d knots, %d rule lines\n",
psSpline->u_order, psSpline->num_poles_u,
psSpline->num_knots_u, psSpline->rule_lines_u);
fprintf( fp, " V: properties=%02x",
psSpline->v_properties);
if (psSpline->v_properties != 0) {
if (psSpline->v_properties & DGNBSS_ARC_SPACING) {
fprintf(fp, ",ARC_SPACING");
}
if (psSpline->v_properties & DGNBSS_CLOSED) {
fprintf(fp, ",CLOSED");
}
}
fprintf(fp, "\n");
fprintf( fp, " order=%d\n %d poles, %d knots, %d rule lines\n",
psSpline->v_order, psSpline->num_poles_v,
psSpline->num_knots_v, psSpline->rule_lines_v);
}
break;
case DGNST_BSPLINE_CURVE_HEADER:
{
DGNElemBSplineCurveHeader *psSpline =
(DGNElemBSplineCurveHeader *) psElement;
fprintf( fp,
" desc_words=%ld, curve type=%d\n"
" properties=%02x",
psSpline->desc_words, psSpline->curve_type,
psSpline->properties);
if (psSpline->properties != 0) {
if (psSpline->properties & DGNBSC_CURVE_DISPLAY) {
fprintf(fp, ",CURVE_DISPLAY");
}
if (psSpline->properties & DGNBSC_POLY_DISPLAY) {
fprintf(fp, ",POLY_DISPLAY");
}
if (psSpline->properties & DGNBSC_RATIONAL) {
fprintf(fp, ",RATIONAL");
}
if (psSpline->properties & DGNBSC_CLOSED) {
fprintf(fp, ",CLOSED");
}
}
fprintf(fp, "\n");
fprintf( fp, " order=%d\n %d poles, %d knots\n",
psSpline->order, psSpline->num_poles, psSpline->num_knots);
}
break;
case DGNST_BSPLINE_SURFACE_BOUNDARY:
{
DGNElemBSplineSurfaceBoundary *psBounds =
(DGNElemBSplineSurfaceBoundary *) psElement;
fprintf( fp, " boundary number=%d, # vertices=%d\n",
psBounds->number, psBounds->numverts);
for (int i=0;i<psBounds->numverts;i++) {
fprintf( fp, " (%.6f,%.6f)\n",
psBounds->vertices[i].x,
psBounds->vertices[i].y);
}
}
break;
case DGNST_KNOT_WEIGHT:
{
DGNElemKnotWeight *psArray = (DGNElemKnotWeight *) psElement;
int numelems = (psArray->core.size-36)/4;
for (int i=0;i<numelems;i++) {
fprintf(fp, " %.6f\n", psArray->array[i]);
}
}
break;
default:
break;
}
if( psElement->attr_bytes > 0 )
{
int iLink;
fprintf( fp, "Attributes (%d bytes):\n", psElement->attr_bytes );
for( iLink = 0; true; iLink++ )
{
int nLinkType, nEntityNum=0, nMSLink=0, nLinkSize, i;
unsigned char *pabyData;
pabyData = DGNGetLinkage( hDGN, psElement, iLink, &nLinkType,
&nEntityNum, &nMSLink, &nLinkSize );
if( pabyData == NULL )
break;
fprintf( fp, "Type=0x%04x", nLinkType );
if( nMSLink != 0 || nEntityNum != 0 )
fprintf( fp, ", EntityNum=%d, MSLink=%d",
nEntityNum, nMSLink );
int nBytes = static_cast<int>(psElement->attr_data + psElement->attr_bytes - pabyData);
if( nBytes < nLinkSize )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Corrupt linkage, element id:%d, link:%d",
psElement->element_id, iLink);
fprintf(fp, " (Corrupt, declared size: %d, assuming size: %d)",
nLinkSize, nBytes);
nLinkSize = nBytes;
}
fprintf( fp, "\n 0x" );
for( i = 0; i < nLinkSize; i++ )
fprintf( fp, "%02x", pabyData[i] );
fprintf( fp, "\n" );
}
}
}
OGRFeature *OGRDGNLayer::ElementToFeature( DGNElemCore *psElement )
{
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetFID( psElement->element_id );
poFeature->SetField( "Type", psElement->type );
poFeature->SetField( "Level", psElement->level );
poFeature->SetField( "GraphicGroup", psElement->graphic_group );
poFeature->SetField( "ColorIndex", psElement->color );
poFeature->SetField( "Weight", psElement->weight );
poFeature->SetField( "Style", psElement->style );
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Collect linkage information */
/* -------------------------------------------------------------------- */
#define MAX_LINK 100
int anEntityNum[MAX_LINK], anMSLink[MAX_LINK];
unsigned char *pabyData;
int iLink=0, nLinkCount=0;
anEntityNum[0] = 0;
anMSLink[0] = 0;
pabyData = DGNGetLinkage( hDGN, psElement, iLink, NULL,
anEntityNum+iLink, anMSLink+iLink, NULL );
while( pabyData && nLinkCount < MAX_LINK )
{
iLink++;
if( anEntityNum[nLinkCount] != 0 || anMSLink[nLinkCount] != 0 )
nLinkCount++;
anEntityNum[nLinkCount] = 0;
anMSLink[nLinkCount] = 0;
pabyData = DGNGetLinkage( hDGN, psElement, iLink, NULL,
anEntityNum+nLinkCount, anMSLink+nLinkCount,
NULL );
}
/* -------------------------------------------------------------------- */
/* Apply attribute linkage to feature. */
/* -------------------------------------------------------------------- */
if( nLinkCount > 0 )
{
if( EQUAL(pszLinkFormat,"FIRST") )
{
poFeature->SetField( "EntityNum", anEntityNum[0] );
poFeature->SetField( "MSLink", anMSLink[0] );
}
else if( EQUAL(pszLinkFormat,"LIST") )
{
poFeature->SetField( "EntityNum", nLinkCount, anEntityNum );
poFeature->SetField( "MSLink", nLinkCount, anMSLink );
}
else if( EQUAL(pszLinkFormat,"STRING") )
{
char szEntityList[MAX_LINK*9], szMSLinkList[MAX_LINK*9];
int nEntityLen = 0, nMSLinkLen = 0;
for( iLink = 0; iLink < nLinkCount; iLink++ )
{
if( iLink != 0 )
{
szEntityList[nEntityLen++] = ',';
szMSLinkList[nMSLinkLen++] = ',';
}
sprintf( szEntityList + nEntityLen, "%d", anEntityNum[iLink]);
sprintf( szMSLinkList + nMSLinkLen, "%d", anMSLink[iLink] );
nEntityLen += strlen(szEntityList + nEntityLen );
nMSLinkLen += strlen(szMSLinkList + nMSLinkLen );
}
poFeature->SetField( "EntityNum", szEntityList );
poFeature->SetField( "MSLink", szMSLinkList );
}
}
/* -------------------------------------------------------------------- */
/* Lookup color. */
/* -------------------------------------------------------------------- */
char gv_color[128];
int gv_red, gv_green, gv_blue;
char szFSColor[128], szPen[256];
szFSColor[0] = '\0';
if( DGNLookupColor( hDGN, psElement->color,
&gv_red, &gv_green, &gv_blue ) )
{
sprintf( gv_color, "%f %f %f 1.0",
gv_red / 255.0, gv_green / 255.0, gv_blue / 255.0 );
sprintf( szFSColor, "c:#%02x%02x%02x",
gv_red, gv_green, gv_blue );
}
/* -------------------------------------------------------------------- */
/* Generate corresponding PEN style. */
/* -------------------------------------------------------------------- */
if( psElement->style == DGNS_SOLID )
sprintf( szPen, "PEN(id:\"ogr-pen-0\"" );
else if( psElement->style == DGNS_DOTTED )
sprintf( szPen, "PEN(id:\"ogr-pen-5\"" );
else if( psElement->style == DGNS_MEDIUM_DASH )
sprintf( szPen, "PEN(id:\"ogr-pen-2\"" );
else if( psElement->style == DGNS_LONG_DASH )
sprintf( szPen, "PEN(id:\"ogr-pen-4\"" );
else if( psElement->style == DGNS_DOT_DASH )
sprintf( szPen, "PEN(id:\"ogr-pen-6\"" );
else if( psElement->style == DGNS_SHORT_DASH )
sprintf( szPen, "PEN(id:\"ogr-pen-3\"" );
else if( psElement->style == DGNS_DASH_DOUBLE_DOT )
sprintf( szPen, "PEN(id:\"ogr-pen-7\"" );
else if( psElement->style == DGNS_LONG_DASH_SHORT_DASH )
sprintf( szPen, "PEN(p:\"10px 5px 4px 5px\"" );
else
sprintf( szPen, "PEN(id:\"ogr-pen-0\"" );
if( strlen(szFSColor) > 0 )
sprintf( szPen+strlen(szPen), ",%s", szFSColor );
if( psElement->weight > 1 )
sprintf( szPen+strlen(szPen), ",w:%dpx", psElement->weight );
strcat( szPen, ")" );
switch( psElement->stype )
{
case DGNST_MULTIPOINT:
if( psElement->type == DGNT_SHAPE )
{
OGRLinearRing *poLine = new OGRLinearRing();
OGRPolygon *poPolygon = new OGRPolygon();
DGNElemMultiPoint *psEMP = (DGNElemMultiPoint *) psElement;
poLine->setNumPoints( psEMP->num_vertices );
for( int i = 0; i < psEMP->num_vertices; i++ )
{
poLine->setPoint( i,
psEMP->vertices[i].x,
psEMP->vertices[i].y,
psEMP->vertices[i].z );
}
poPolygon->addRingDirectly( poLine );
poFeature->SetGeometryDirectly( poPolygon );
ConsiderBrush( psElement, szPen, poFeature );
}
else if( psElement->type == DGNT_CURVE )
{
DGNElemMultiPoint *psEMP = (DGNElemMultiPoint *) psElement;
OGRLineString *poLine = new OGRLineString();
DGNPoint *pasPoints;
int nPoints;
nPoints = 5 * psEMP->num_vertices;
pasPoints = (DGNPoint *) CPLMalloc(sizeof(DGNPoint) * nPoints);
DGNStrokeCurve( hDGN, psEMP, nPoints, pasPoints );
poLine->setNumPoints( nPoints );
for( int i = 0; i < nPoints; i++ )
{
poLine->setPoint( i,
pasPoints[i].x,
pasPoints[i].y,
pasPoints[i].z );
}
poFeature->SetGeometryDirectly( poLine );
CPLFree( pasPoints );
poFeature->SetStyleString( szPen );
}
else
{
OGRLineString *poLine = new OGRLineString();
DGNElemMultiPoint *psEMP = (DGNElemMultiPoint *) psElement;
if( psEMP->num_vertices > 0 )
{
poLine->setNumPoints( psEMP->num_vertices );
for( int i = 0; i < psEMP->num_vertices; i++ )
{
poLine->setPoint( i,
psEMP->vertices[i].x,
psEMP->vertices[i].y,
psEMP->vertices[i].z );
}
poFeature->SetGeometryDirectly( poLine );
}
poFeature->SetStyleString( szPen );
}
break;
case DGNST_ARC:
{
OGRLineString *poLine = new OGRLineString();
DGNElemArc *psArc = (DGNElemArc *) psElement;
DGNPoint asPoints[90];
int nPoints;
nPoints = (int) (MAX(1,ABS(psArc->sweepang) / 5) + 1);
DGNStrokeArc( hDGN, psArc, nPoints, asPoints );
poLine->setNumPoints( nPoints );
for( int i = 0; i < nPoints; i++ )
{
poLine->setPoint( i,
asPoints[i].x,
asPoints[i].y,
asPoints[i].z );
}
poFeature->SetGeometryDirectly( poLine );
poFeature->SetStyleString( szPen );
}
break;
case DGNST_TEXT:
{
OGRPoint *poPoint = new OGRPoint();
DGNElemText *psText = (DGNElemText *) psElement;
char *pszOgrFS;
poPoint->setX( psText->origin.x );
poPoint->setY( psText->origin.y );
poPoint->setZ( psText->origin.z );
poFeature->SetGeometryDirectly( poPoint );
pszOgrFS = (char *) CPLMalloc(strlen(psText->string) + 150);
// setup the basic label.
sprintf( pszOgrFS, "LABEL(t:\"%s\"", psText->string );
// set the color if we have it.
if( strlen(szFSColor) > 0 )
sprintf( pszOgrFS+strlen(pszOgrFS), ",%s", szFSColor );
// Add the size info in ground units.
if( ABS(psText->height_mult) >= 6.0 )
sprintf( pszOgrFS+strlen(pszOgrFS), ",s:%dg",
(int) psText->height_mult );
else if( ABS(psText->height_mult) > 0.1 )
sprintf( pszOgrFS+strlen(pszOgrFS), ",s:%.3fg",
psText->height_mult );
else
sprintf( pszOgrFS+strlen(pszOgrFS), ",s:%.12fg",
psText->height_mult );
// Add the font name. Name it MstnFont<FONTNUMBER> if not available
// in the font list. #3392
static const char *papszFontList[] =
{ "STANDARD", "WORKING", "FANCY", "ENGINEERING", "NEWZERO", "STENCEL", //0-5
"USTN_FANCY", "COMPRESSED", "STENCEQ", NULL, "hand", "ARCH", //6-11
"ARCHB", NULL, NULL, "IGES1001", "IGES1002", "IGES1003", //12-17
"CENTB", "MICROS", NULL, NULL, "ISOFRACTIONS", "ITALICS", //18-23
"ISO30", NULL, "GREEK", "ISOREC", "Isoeq", NULL, //24-29
"ISO_FONTLEFT", "ISO_FONTRIGHT", "INTL_ENGINEERING", "INTL_WORKING", "ISOITEQ", NULL, //30-35
"USTN FONT 26", NULL, NULL, NULL, NULL, "ARCHITECTURAL", //36-41
"BLOCK_OUTLINE", "LOW_RES_FILLED", NULL, NULL, NULL, NULL, //42-47
NULL, NULL, "UPPERCASE", NULL, NULL, NULL, //48-53
NULL, NULL, NULL, NULL, NULL, NULL, //54-49
"FONT060", "din", "dinit", "helvl", "HELVLIT", "helv", //60-65
"HELVIT", "cent", "CENTIT", "SCRIPT", NULL, NULL, //66-71
NULL, NULL, NULL, NULL, "MICROQ", "dotfont", //72-77
"DOTIT", NULL, NULL, NULL, NULL, NULL, //78-83
NULL, NULL, NULL, NULL, NULL, NULL, //84-89
NULL, NULL, "FONT092", NULL, "FONT094", NULL, //90-95
NULL, NULL, NULL, NULL, "ANSI_SYMBOLS", "FEATURE_CONTROL_SYSMBOLS", //96-101
"SYMB_FAST", NULL, NULL, "INTL_ISO", "INTL_ISO_EQUAL", "INTL_ISO_ITALIC", //102-107
"INTL_ISO_ITALIC_EQUAL" }; //108
if(psText->font_id <= 108 && papszFontList[psText->font_id] != NULL )
{
sprintf( pszOgrFS+strlen(pszOgrFS), ",f:%s",
papszFontList[psText->font_id] );
}
else
{
sprintf( pszOgrFS+strlen(pszOgrFS), ",f:MstnFont%d",
psText->font_id );
}
// Add the angle, if not horizontal
if( psText->rotation != 0.0 )
sprintf( pszOgrFS+strlen(pszOgrFS), ",a:%d",
(int) (psText->rotation+0.5) );
strcat( pszOgrFS, ")" );
poFeature->SetStyleString( pszOgrFS );
CPLFree( pszOgrFS );
poFeature->SetField( "Text", psText->string );
}
break;
case DGNST_COMPLEX_HEADER:
{
DGNElemComplexHeader *psHdr = (DGNElemComplexHeader *) psElement;
int iChild;
OGRMultiLineString oChildren;
/* collect subsequent child geometries. */
// we should disable the spatial filter ... add later.
for( iChild = 0; iChild < psHdr->numelems; iChild++ )
{
OGRFeature *poChildFeature = NULL;
DGNElemCore *psChildElement;
psChildElement = DGNReadElement( hDGN );
// should verify complex bit set, not another header.
if( psChildElement != NULL )
{
poChildFeature = ElementToFeature( psChildElement );
DGNFreeElement( hDGN, psChildElement );
}
if( poChildFeature != NULL
&& poChildFeature->GetGeometryRef() != NULL )
{
OGRGeometry *poGeom;
poGeom = poChildFeature->GetGeometryRef();
if( wkbFlatten(poGeom->getGeometryType()) == wkbLineString )
oChildren.addGeometry( poGeom );
}
if( poChildFeature != NULL )
delete poChildFeature;
}
// Try to assemble into polygon geometry.
OGRGeometry *poGeom;
if( psElement->type == DGNT_COMPLEX_SHAPE_HEADER )
poGeom = (OGRPolygon *)
OGRBuildPolygonFromEdges( (OGRGeometryH) &oChildren,
TRUE, TRUE, 100000, NULL );
else
poGeom = oChildren.clone();
if( poGeom != NULL )
poFeature->SetGeometryDirectly( poGeom );
ConsiderBrush( psElement, szPen, poFeature );
}
break;
default:
break;
}
/* -------------------------------------------------------------------- */
/* Fixup geometry dimension. */
/* -------------------------------------------------------------------- */
if( poFeature->GetGeometryRef() != NULL )
poFeature->GetGeometryRef()->setCoordinateDimension(
DGNGetDimension( hDGN ) );
return poFeature;
}
