OpenCASCADE DataExchange DWG

/*
 * load_dwg.c: load a DWG, get lines, text and circles
 * written by Felipe Castro
 * modified by Felipe Corrêa da Silva Sances
 * modified by Thien-Thi Nguyen
 */

#include <dwg.h>
#include \"suffix.c\"

void add_line(double x1, double y1, double x2, double y2)
{
  // Make something with that
}

void add_circle(double x, double y, double R)
{
  // Make something with that
}

void add_text(double x, double y, char *txt)
{
  // Make something with that
}

int load_dwg(char *filename)
{
  unsigned int i;
  int success;
  Dwg_Data dwg;

  dwg.num_objects = 0;
  success = dwg_read_file(filename, &dwg);
  for (i = 0; i < dwg.num_objects; i++)
    {
      Dwg_Entity_LINE *line;
      Dwg_Entity_CIRCLE *circle;
      Dwg_Entity_TEXT *text;

      switch (dwg.object[i].type)
        {
      case DWG_TYPE_LINE:
        line = dwg.object[i].tio.entity->tio.LINE;
        add_line(line->start.x, line->end.x, line->start.y, line->end.y);
        break;
      case DWG_TYPE_CIRCLE:
        circle = dwg.object[i].tio.entity->tio.CIRCLE;
        add_circle(circle->center.x, circle->center.y, circle->radius);
        break;
      case DWG_TYPE_TEXT:
        text = dwg.object[i].tio.entity->tio.TEXT;
        add_text(text->insertion_pt.x, text->insertion_pt.y, text->text_value);
        break;
        }
    }
  dwg_free(&dwg);
  return success;
}

int main (int argc, char *argv[])
{
  REQUIRE_INPUT_FILE_ARG (argc);
  load_dwg (argv[1]);
  return 0;
}

/*
*    Copyright (c) 2014 eryar All Rights Reserved.
*
*        File    : Main.cpp
*        Author  : eryar@163.com
*        Date    : 2014-10-15 20:46
*        Version : 1.0v
*
*    Description : Use libredwg to read data from DWG and
*                  output them to Tcl script for Draw.
*
*      Key words : OpenCASCADE, libredwg, Draw Test Harness
*/

#include \"dwg.h\"

#include <fstream>
#include <iostream>

#pragma comment(lib, \"../Debug/libredwg.lib\")

// Output the entities to Tcl for OpenCASCADE Draw.
static std::ofstream theTclExporter(\"d:/dwg2occ.tcl\");


void OutputLine(int id, const Dwg_Entity_LINE* theLine)
{
    // Draw Tcl command: vline name xa ya za xb yb zb
    theTclExporter << \"vline line\" << id << \" \" 
        << theLine->start.x << \" \" << theLine->start.y << \" \" << theLine->start.z << \" \" 
        << theLine->end.x << \" \" << theLine->end.y << \" \" << theLine->end.z << std::endl;
}

void OutputCircle(int id, const Dwg_Entity_CIRCLE* theCircle)
{
    // Draw Tcl command: circle name x y [z [dx dy dz]] [ux uy [uz]] radius
    // 1. make a curve
    theTclExporter << \"circle circle\" << id << \" \"
        << theCircle->center.x << \" \" << theCircle->center.y << \" \" << theCircle->center.z << \" \" 
        << \"0 0 1 \" << theCircle->radius << std::endl;

    // 2. make edge from the circle
    theTclExporter << \"mkedge e\" << id << \" \"
        << \"circle\" << id << std::endl;

    // 3. display the circle edge
    theTclExporter << \"vdisplay e\" << id << std::endl;
}

void OutputText(int id, const Dwg_Entity_TEXT* theText)
{
    // vdrawtext : vdrawtext  : vdrawtext name X Y Z R G B hor_align ver_align angle zoomable height Aspect [Font [isMultiByte]]
    theTclExporter << \"vdrawtext \" << theText->text_value << \" \"
        << theText->insertion_pt.x << \" \" << theText->insertion_pt.y << \" 0\" 
        << \" 255 255 000 \" 
        << theText->horiz_alignment << \" \" << theText->vert_alignment << \" \" 
        << theText->height << \" 1 Times-Roman\"<< std::endl;
}

int LoadDwg(char* theDwgFile)
{
    int aResult = 0;

    Dwg_Data aDwgData;

    aResult = dwg_read_file(theDwgFile, &aDwgData);

    for (unsigned int i = 0; i < aDwgData.num_objects; ++i)
    {
        switch (aDwgData.object[i].type)
        {
        case DWG_TYPE_LINE:
            OutputLine(i, aDwgData.object[i].tio.entity->tio.LINE);
            break;

        case DWG_TYPE_CIRCLE:
            OutputCircle(i, aDwgData.object[i].tio.entity->tio.CIRCLE);
            break;

        case DWG_TYPE_TEXT:
            OutputText(i, aDwgData.object[i].tio.entity->tio.TEXT);
            break;
        }
    }

    return aResult;
}

int main(int argc, char* argv[])
{
    theTclExporter.flags(std::ios::fixed);

    theTclExporter << \"pload ALL\" << std::endl;
    theTclExporter << \"vinit\" << std::endl;
    theTclExporter << \"vtrihedron tr\" << std::endl;

    if (argc < 1)
    {
        std::cout << \"please input the dwg file name!\" << std::endl;
    }
    else
    {
        LoadDwg(argv[1]);
    }

    theTclExporter << \"vdisplayall\" << std::endl;
    theTclExporter << \"vfit\" << std::endl;
    theTclExporter << \"vhelp\" << std::endl;

    return 0;
}