Utilizando formatos de arquivo AutoCAD com bibliotecas de software livre

Resumo: Muitos especialistas usam o AutoCAD e seus formatos em engenharia, design, arquitetura, geografia e campos relacionados. Pode ser til combinar os dados produzidos pelo AutoCAD com dados de GIS comoshapefiles para localizaes em mapas ou para o uso interno no Google Earth ou Google Maps. Saiba mais sobre duas bibliotecas de software livre LibreDWG e dxflibque tornam os formatos de arquivo AutoCAD DXF e DWG mais acessveis. possvel tambm criar uma ferramenta de converso para os formatos KML e shapefile e que utilize a biblioteca GDAL para facilitar o trabalho com formatos de arquivo GML e shapefile.

Introduo
Muitos desenvolvedores e profissionais de geographic information system (GIS) no conseguiam utilizar um arquivo Drawing Interchange Format (DXF) ou "drawing" (DWG). Estes formatos AutoCAD geralmente requerem o Windows e uma cpia do AutoCAD para serem abertos. Ao utilizar algumas bibliotecas de software livre teis, possvel fazer com que seus aplicativos leiam arquivos DXF e DWG em qualquer sistema operacional, sem custo algum. Neste artigo, voc construir um conversor para traduzir estes formatos de arquivos em formatos ESRI shapefile ou keyhole markup language (KML) mais acessveis. Softwares comerciais e livres utilizam ESRI Shapefiles, enquanto que o Google Earth e o Google Maps usam principalmente o KML. Voltar para parte superior

AutoCAD DWG e LibreDWG

O formato AutoCAD mais comum o "drawing", com a extenso .dwg. Poucos aplicativos de software podem ler este formato, que o padro ao salvar arquivos no AutoCAD. Entretanto, possvel usar a biblioteca de software livre LibreDWG (vejaRecursospara ler estes arquivos. O formato de arquivo consiste de um bloco de controle, que contm locos adicionais representando as formas no arquivo, e blocos para espao de modelo e espao em papel, que representa compensaes para as coordenadas internas do documento. Usa-se a biblioteca abrindo o documento e lendo o arquivo, fazendo depois um loop por cada bloco no bloco de controle central, como mostra a Listagem 1. Listagem 1. Abertura de um arquivo DWG e loop pelo bloco de controle central
Dwg_Data dwg = new Dwg_Data(); int errno = dwg_read_file((char *)inputFilename, dwg); if (errno) { fprintf(stderr, "Could not open DWG. Returned error code: $d\n", errno); delete dwg; } Dwg_Object_BLOCK_CONTROL * ctrl = dwg->object[0].tio.object->tio.BLOCK_CONTROL; dumpBlock(ctrl->model_space); dumpBlock(ctrl->paper_space); for (int i = 0; i < ctrl->num_entries; i++) { dumpBlock(ctrl->block_headers[i]); } dwg_free(dwg);

Cada bloco pode representar qualquer um dos vrios tipos de geometria: uma linha, crculo, texto, arco, aplicado a um local ou a uma insero (um deslocamento a ser aplicado a blocos posteriores). Voc trabalha com um por vez, acessando as propriedades nos objetos do bloco que get_first_owned_object e get_next_owned_object retornam, como ilustrado naListagem 2. Listagem 2. Leitura de objetos com get_first_owned_object e get_next_owned_object
void InputFormatDWG::dumpBlock(Dwg_Object_Ref * block) { if (!block) return; if (!block->obj) return; if (!block->obj->tio.object) return; Dwg_Object_BLOCK_HEADER * header = block->obj->tio.object->tio.BLOCK_HEADER; Dwg_Object * obj = get_first_owned_object(block->obj, header); while (obj) { if (obj->type == DWG_TYPE_LINE) { Dwg_Entity_LINE * line = obj->tio.entity->tio.LINE; printf("Line starting at (%f, %f, %f) ending at (%f, %f, %f)\n", line->start.x, line->start.y, 0, line->end.x, line->end.y, 0); // Don't delete "line" - dwg_free will do this } obj = get_next_owned_object(block->obj, obj, header); } }

Assim, ler um arquivo DWG com o LibreDWG um fluxo sequencial do incio ao fim. Ao implementar a LibreDWG no C++, importante incluir dwg.h dentro de um bloco "C" externo para evitar erros de vinculao. Este um exemplo:
extern "C" { #include <dwg.h> }

Os pr-requisitos para esta biblioteca so os pacotes autoconf, swig, texinfoe pythondev , assim como os pacotes de compilador (essenciais na utilizao de Debian ou Ubuntu). possvel construir a biblioteca fazendo o download dela e inserindo a seguinte linha de comando:
git clone git://git.sv.gnu.org/libredwg.git

. . . seguida de:
./autogen.sh && ./configure && make && sudo make install

Voltar para parte superior

AutoCAD DXF e dxflib

O formato DXF uma opo de exportao de dentro do AutoCAD. Assim, mais aplicativos oferecem suporte a ela do que a DWG, e a especificao do formato de arquivo publicada (vejaRecursos para um link com a especificao de DXF completa). possvel, entretanto, ler estes arquivos utilizando a livraria de software livre dxflib . Diferente da LibreDWG, ler um arquivo DXF exibe menos codificao sequencial. Na verdade utilizar a dxflib como criar um cdigo gerado por evento.

Abre-se o arquivo utilizando a funo in do objeto DL_Dxf e passando o ponteiro para uma classe que herde das classes abstratas do DL_CreationAdapter . Enquanto a funo in executada, ela chama vrias funes na classe passada que est sendo passada. H dezenas dessas funes (veja o link do Guia DXFLib Programmer em Recursos), mas so necessrias apenas algumas na maioria dos casos geralmente addPoint, addLine, addCirclee addVertex. necessrio implementar apenas as funes mais importantes; o resto pode ser omitido. A Listagem 3 mostra um exemplo simples do carregamento de um arquivo DXF e da leitura de algumas linhas. Listagem 3. Carregamento de um arquivo DXF e leitura de linhas
LineReader.h: #ifndef LINEREADER_H #define LINEREADER_H #include "dxflib/src/dl_dxf.h" #include "dxflib/src/dl_creationadapter.h" #include <stdio.h> class LineReader: public DL_CreationAdapter { public: // Our functions: void readLines(const char * filename); // Overloading from parent DL_CreationAdapter: void addLine(const DL_LineData& data); }; #endif LineReader.cpp: void LineReader::readLines(const char * filename) { DL_Dxf * getData = new DL_Dxf(); if (!getData->in(filename, this)) { fprintf(stderr, "Could not retrieve data from input file.\n"); delete getData; exit(1); } delete getData; } void LineReader::addLine(const DL_LineData& data) { printf("Line starting at (%f, %f, %f) ending at (%f, %f, %f)\n", data.x1, data.y1, data.z1, data.x2, data.y2, data.z2); }

Como o DWG, o formato DXF pode conter inseres, que representam compensaes a serem aplicadas a recursos geomtricos encontrados aps a insero. Estas inseres devem ser armazenadas internamente e serem aplicadas a coordenadas na medida em que forem encontradas. Similarmente, adicionar polilinhas (linhas com diversos vrtices) exige o armazenamento de alguns dados. A biblioteca primeiro chama addPolyline, indicando que a linha est sendo feita; depois, chama addVertex para cada vrtice da linha. Por fim, a linha est feita quando endEntity ou endBlock chamado, quando voc j tem a linha e ela pode ser renderizada, exportada para outro formato, ou qualquer outra ao. possvel construir e instalar a biblioteca DXF fazendo o download dela e inserindo a seguinte linha de comando:
./configure && make && sudo make install

Podem surgir mensagens de erro sobre strcasecmp assim como sobre strlen no ser declarado. A biblioteca dxflib foi construda para utilizar o GCC/G++ 4.2, e na verso 4.3, ocorreu a reorganizao de arquivos de cabealho. Consertar este erro exige a incluso em src/dl_writer.h e em src/dl_writer_ascii.h assim como #include <cstring> e #include <cstdlib>perto de outras inseres. Observao: Estas alteraes j foram feitas na cpia da dxflib includa no cdigo de origem do conversor disponvel emDownload, ento esta alterao se aplica apenas se foi feito o download do dxflib diretamente do Web site da dxflib . Voltar para parte superior

KML e texto simples/Xerces-C++

o formato KML que o Google Earth e o Google Maps usam uma forma especial do XML; assim, possvel usar bibliotecas como a Xerces-C++ XML Parser (veja Recursos para um link) para trabalhar com arquivos KML. Ao ler estes formatos, bibliotecas formais como aXerces-C++ so aconselhveis para trabalhar com estruturas mais complexas que possam ser encontradas. Ao escrever, geralmente suficiente usar uma funcionalidade de idioma simples para escrever arquivos de textos, e ento gerar o texto apropriado em si. Um arquivo KML bsico consiste em uma seo de Documento que contenha um nome e uma descrio. Este arquivo pode conter tambm uma ou mais pastas (usadas para organizar as formas de maneira lgica), e dentro de cada pasta h marcadores. Os marcadores so as formas em si, que podem ser definidas como uma linha, um ponto, um polgono ou outros tipos. Criar um arquivo KML exige escrever um texto formatado de maneira adequada, que represente as formas, como mostrado na Listagem 4. Listagem 4. Um arquivo KML simples
<?xml version="1.0" encoding="UTF-8"?> <kml xmlns="http://www.opengis.net/kml/2.2"> <Document> <name>test</name> <open>1</open> <description>Converted from AutoCAD DXF or DWG</description> <Folder> <name>test</name> <Placemark> <LineString> <tessellate>0</tessellate> <coordinates>27.54998,82.27393,0.00000 39.72346,9.25601,0.00000</coordinates> </LineString> </Placemark> </Folder> </Document> </kml>

possvel encontrar tambm arquivos KMZ, que so como os arquivos KML, mas comprimidos pela compresso ZIP. Consulte a seo Recursos para um link de um tutorial para iniciantes sobre o KML e uma documentao completa. Voltar para parte superior

ESRI Shapefile e GDAL/OGR

O formato shapefile um formato de dados binrios comercial (porm livre) publicado pela ESRI (veja Recursos para o link de uma descrio tcnica completa). possvel usar a parte da biblioteca livre OGR Simple Featuredo Geospatial Data Abstraction Layer (GDAL)para acessar estes arquivos facilmente. No exemplo de conversor, necessrio apenas a sada, mas esta biblioteca tambm simplifica a leitura dos dados de formas. Criar

dados exige a abertura de uma fonte de dados de sada e a criao de uma camada de dados dentro dela. possvel criar campos para armazenar dados no espaciais para cada forma. Depois que a fonte de dados de sada for criada, possvel inserir diversas formas (chamadas Recursos) fonte de dados. A criao de um recurso exige a criao de uma geometria, como um ponto ou linha, e a associao desta ao recurso. O recurso age como um continer para todos os dados de campo/no espaciais e geomtricos. A Listagem 5 mostra o cdigo para a criao de uma nova fonte de dados shapefile e um ponto nico dentro do conjunto de dados. Veja o tutorial para leitura/criao do OGR C++ e os links de hierarquia de classes e documentao em Recursos para mais informaes sobre o uso do OGR e para um link de download da biblioteca. A maioria dos repositrios de distribuio do Linux incluem a biblioteca GDAL e arquivos de cabealho como libgdal1-1.7.0 e libgdal1-dev (a verso pode variar). Listagem 5. Criao de um shapefile com um ponto nico
OGRRegisterAll(); OGRSFDriver drv = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName("ESRI Shapefile"); if (drv == NULL) { fprintf(stderr, "Could not open Shapefile OGR driver.\n"); return; } OGRDataSource ds = drv->CreateDataSource(filename, NULL); if (ds == NULL) { fprintf(stderr, "Could not create output file.\n"); return; } OGRLayer lyr = ds->CreateLayer("Layer", NULL, wkbPoint, NULL); if (lyr == NULL) { fprintf(stderr, "Could not create layer.\n"); return; } // Add an ID field OGRFieldDefn newField("id", OFTInteger); newField.SetWidth(32); lyr->CreateField(&newField); if (!lyr) { fprintf(stderr, "No output layer is available."); return; } OGRFeature * newFeat = OGRFeature::CreateFeature(lyr->GetLayerDefn()); newFeat->SetField("id", lyr->GetFeatureCount(1)); OGRPoint point; point.setX(15.653); point.setY(43.783); point.setZ(0); newFeat->SetGeometry(&point); lyr->CreateFeature(newFeat); // Clean up your memory OGRFeature::DestroyFeature(newFeat); if (ds) { // Will trigger saving the file and also // clean up any layer references from Create/Get Layer calls OGRDataSource::DestroyDataSource(ds); }

Voltar para parte superior

Implementao das bibliotecas de formato de arquivo

H trs maneiras principais de se implementar uma biblioteca de formato de arquivo no software. A primeira implementao nativa nos aplicativos exige que voc possa usar as bibliotecas diretamente de seu cdigo, o que significa que talvez seja preciso escrever seu cdigo em um grupo particular de idiomas, dependendo da disponibilidade de ligao. Exige tambm algumas ligaes fortes, que podem causar erros pequenos quando verses da biblioteca forem atualizadas. Entretanto, a implementao direta no aplicativo torna o uso do formato mais suave para os usurios. Outro mtodo consiste em escrever um plug-in ou extenso para seu aplicativo que fornea suporte para os formatos de arquivo desejados. Este mtodo cria certo grau de separao entre uma biblioteca de formato de arquivo e seu cdigo de aplicativo. Se seu aplicativo j possui uma estrutura de plug-in, isso pode ser uma boa opo. Por exemplo, o Quantum GIS, uma aplicativo GIS de desktop comum, utiliza uma arquitetura de plug-in; um plug-in que permite o uso de arquivos de texto delimitados diretamente em seu aplicativo. O ltimo e mais simples mtodo um conversor independente pode ser criado para converter entre dois ou mais formatos de arquivos. Esta tcnica tem a vantagem de ser reutilizvel, independentemente de suas metas finais para os dados, pelo custo de criar outra etapa para os usurios. Voltar para parte superior

Um conversor de linha de comando deDXF/DWG para KML/Shapefile

Neste exemplo, voc usa a rota mais simples e reutilizvel de criar um Tradutor de formato de arquivo. Seu objetivo criar um conversor que fcil de estender para lidar com formatos adicionais e que mantm a lgica de qualquer determinada entrada ou formato de sada, da maneira mais separada possvel. Estas metas levam definio de duas classes abstratas:InputFormat e OutputFormat (consulte a Listagem 6). Listagem 6. Definio das classes abstratas InputFormat e OutputFormat
OutputFormat.h: #ifndef OUTPUTFORMAT_H #define OUTPUTFORMAT_H #include "OutputFormatTypes.h" #include <vector> class OutputFormat { public: OutputFormat() {}; ~OutputFormat() {}; // Standard feature types: virtual void addPoint(OutputFeaturePoint newPoint) = 0; virtual void addLine(OutputFeatureLine newLine) = 0; virtual void addPolyLine(std::vector<OutputFeaturePoint *> newPoints) = 0; virtual void addPolygon(std::vector<OutputFeaturePoint *> newPoints) = 0; // For approximating text on DXF/DWG with a separate point layer with // a label attribute: virtual void addText(OutputFeaturePoint location, const char * text) = 0; // The cleanup function virtual void finalizeOutput() = 0;

}; #endif InputFormat.h: #ifndef INPUTFORMAT_H #define INPUTFORMAT_H #include "OutputFormat.h" class InputFormat { public: InputFormat() {}; ~InputFormat() {}; virtual void readFeaturesInto(OutputFormat * outputHandler) = 0; }; #endif

Qualquer formato implementado deve herdar uma dessas classes. Assim, a principal funo e ponto de entrada do programa pode lidar exclusivamente com a determinao de qual classe instanciar. Aps a definio de um arquivo de entrada e um de sada, a converso pode acontecer com uma nica linha de cdigo:
input->readFeaturesInto(output);

O papel da funo principal (veja a Listagem 7) torna-se apenas instanciar os formatos de entrada e de sada correto, culminando na funo readFeaturesInto sendo executada. Listagem 7. A principal funo do conversor AutoCAD
void usage(char * me) { printf("Usage: %s inputfile outputfile [point|line|polygon]\n", me); printf("Input formats supported:\n"); printf("\tAutoCAD DXF (*.dxf)\n"); printf("\tAutoCAD DWG (*.dwg)\n"); printf("Output formats supported:\n"); printf("\tText (*.txt)\n"); printf("\tESRI Shapefile (*.shp)\n"); printf("\tKeyhold Markup Language (*.kml)\n"); printf("\nInput format and output format are determined automatically by file extension. \n"); printf("If you use a shapefile as the output format, please additionally specify\n"); printf("point, line, or polygon output shapefile type.\n"); } int main(int argc, char * argv[]) { if (argc < 3) { usage(argv[0]); return 1; } OutputFormat * output = NULL; InputFormat * input = NULL; struct stat fileExists; // Set up output format first... std::string outFile = argv[2]; if (outFile.rfind('.') == std::string::npos) { printf("I couldn't make sense of your output filename's extension: %s. Please use filename.shp, filename.kml, or filename.txt.\n", argv[2]); return 1; }

if (outFile.substr(outFile.rfind('.')+1) == "txt") { printf("Setting up output file %s...\n", argv[2]); output = new OutputFormatText(argv[2]); } else if (outFile.substr(outFile.rfind('.')+1) == "shp") { if (argc < 4) { printf("When specifying shapefile output, please also specify 'point', 'line', or 'polygon'. See usage.\n"); return 1; } std::string textAttributeFile = outFile.substr(0, outFile.rfind('.')) + "_text.shp"; OGRwkbGeometryType type; if (strcmp(argv[3], "line") == 0) { type = wkbLineString; } else if (strcmp(argv[3], "point") == 0) { type = wkbPoint; } else if (strcmp(argv[3], "polygon") == 0) { type = wkbPolygon; } else { printf("I didn't understand %s. Please use point, line, or polygon.\n", argv[3]); return 1; } printf("Setting up output file %s...\n", argv[2]); output = new OutputFormatSHP(argv[2], textAttributeFile.c_str(), outFile.substr(0, outFile.rfind('.')).c_str(), type); } else if (outFile.substr(outFile.rfind('.')+1) == "kml") { printf("Setting up output file %s...\n", argv[2]); output = new OutputFormatKML(argv[2], outFile.substr(0, outFile.rfind('.')).c_str()); } // Next grab the input file std::string inFile = argv[1]; if (inFile.rfind('.') == std::string::npos) { printf("I couldn't make sense of your input filename's extension: %s. Please use filename.dxf or filename.dwg.\n", argv[1]); delete output; return 1; } if (stat(argv[1], &fileExists) != 0) { printf("The specified input file does not exist or is not accessible: %s\n", argv[1]); return 1; } if (inFile.substr(inFile.rfind('.')+1) == "dxf") { input = new InputFormatDXF(argv[1]); printf("Setting up input file %s...\n", argv[1]); } else if (inFile.substr(inFile.rfind('.')+1) == "dwg") { input = new InputFormatDWG(argv[1]); printf("Setting up input file %s...\n", argv[1]); } if (!input) { printf("The input file was not recognized or could not be opened.\n"); return 1; } if (!output) { printf("The output file was not recognized or could not be opened.\n"); return 1; }

printf("Converting file...\n"); input->readFeaturesInto(output); output->finalizeOutput(); printf("Done!\n"); delete input; delete output; return 0; }

A nica funo exigida na classe InputFormat readFeaturesInto, que mantm aberta para o formato de entrada individual como se deseja, para fornecer recursos (formas) para a classe de sada fornecida. A classe OutputFormat possui algumas outras funes, entretanto funes para adicionar vrios tipos de formas geomtricas. possvel definir suas prprias classes para ponto e linha para poder fornecer todos os argumentos como valores duplos, ao invs de nmeros inteiros, para o fornecimento de um eixo z. O formato ESRI Shapefile possui uma limitao importante; ele pode apenas armazenar formas de um nico tipo (por exemplo, linhas, pontos ou polgonos). Nenhum outro formato discutido neste artigo DXF, DWG, e KML possui esta restrio. Na classe OutputFormatSHP verifica-se para ver qual tipo de shapefile est sendo criado; se no for do tipo certo, voc lida da melhor maneira possvel. Ao criar um shapefile de ponto, ao ser pedido para adicionar uma forma de polilinha, adicione cada vrtice como um ponto individual. Ao criar um shapefile de linha, se for pedido para inserir um ponto, um aviso de erro padro indica que a forma foi ignorada. Os formatos de arquivo DXF e DWG suportam tambm arcos e crculos, que podem ser aproximados no formato de sada criando diversos segmentos de linhas pequenas aproximando o crculo ou o arco. Ao compilar o aplicativo de exemplo, uma mensagem de erro pode ocorrer relacionada ao dwg.h. Ambas as bibliotecas dxflibe LibreDWG definem a definio global THICKNESS, ento edite o arquivo dwg.h file no local de instalao (por exemplo, /usr/local/include/dwg.h) e altere o nome da constante THICKNESS ou adicione um sublinhado (_) no final. (Isso no usado neste cdigo de exemplo.) Observao: Consulte a seo Download para um cdigo de fonte completo deste exemplo de conversor de formato de arquivo. Voltar para parte superior

insero do conversor em um Web site

Neste ponto, voc j tem um conversor totalmente funcional de linha de comando para formatos de arquivo. No entanto, a maioria dos usurios que normalmente pergunta como ler estes arquivos no consegue usar a linha de comando ou no so capazes de construir o conversor a partir da fonte. Faz sentido, ento, fornecer uma simples porta de entrada com base na Web para essa ferramenta, para que as pessoas que necessitam de converso rpida de um ou dois arquivos pode facilmente faz-lo. Ao mesmo tempo, voc pode criar um sistema em que arquivos so convertidos automaticamente quando adicionado a um diretrio especfico no disco til para interao de FTP ou para acesso por meio de um compartilhamento de arquivo CIFS. Primeiro, crie alguns diretrios para os vrios tipos de formatos de sada shapefile: uploads_KML e uploads_Text para KML e formatos de sada de texto uploads_Point, uploads_Polyline, e uploads_Polygon para os vrios tipos de formato de sada shapefile A conveno ser que qualquer arquivo DXF ou DWG carregado em qualquer uma desses locais sero convertidos para o formato do nome do diretrio implica. Sadas devem ser colocadas em outro diretrio, chamado sadas. Com tal configurao, possvel construir um script de BASH shell simples(vejaa Listagem 8) para verificar por arquivos DWG e DXF neste local e acionar o conversor com os

argumentos de argumento de linha de comandos apropriados. Para ajudar em uma depurao futura, este script pode salvar inputs carregados juntos com sadas geradas em um arquivo .zip para uso administrativo. possvel definir este script para ser periodicamente executado como uma tarefa cron ou para uso de FTP e CIFS (compartilhamento de arquivo do Windows) como um conversor automtico. Listagem 8. Script BASH para verificar por arquivos com converso pendente e pass-los para o conversor
#!/bin/bash -u # Polyline Shapefile queue cd /var/www/acadconverter.chrismichaelis.com/uploads_Polyline for file in /var/www/acadconverter.chrismichaelis.com/uploads_Polyline/*.d*; do [[ "$file" =~ .dxf$ || "$file" =~ dwg$ ]] && { base=$(basename "$file") base=${base%.dwg} base=${base%.dxf} /var/www/acadconverter.chrismichaelis.com/bin/AutoCADConverter \ "$file" "$base.shp" line [ -e "../outputs/$base.zip" ] && rm -f "../outputs/$base.zip" zip "../outputs/$base.zip" "$base.shx" "$base.shp" "$base.dbf" \ "${base}_text.shp" "${base}_text.shx" "${base}_text.dbf" zip "../uploads_done/$(date +%s)_$base.zip" "$base.shx" "$base.shp" "$base.dbf" \ "${base}_text.shp" "${base}_text.shx" "${base}_text.dbf" "$file" rm -f "$file" "$base.shx" "$base.shp" "$base.dbf" "${base}_text.shp" \ "${base}_text.shx" "${base}_text.dbf" } done # Polygon Shapefile queue cd /var/www/acadconverter.chrismichaelis.com/uploads_Polygon for file in /var/www/acadconverter.chrismichaelis.com/uploads_Polygon/*.d*; do [[ "$file" =~ .dxf$ || "$file" =~ dwg$ ]] && { base=$(basename "$file") base=${base%.dwg} base=${base%.dxf} /var/www/acadconverter.chrismichaelis.com/bin/AutoCADConverter "$file" \ "$base.shp" polygon [ -e "../outputs/$base.zip" ] && rm -f "../outputs/$base.zip" zip "../outputs/$base.zip" "$base.shx" "$base.shp" "$base.dbf" \ "${base}_text.shp" "${base}_text.shx" "${base}_text.dbf" zip "../uploads_done/$(date +%s)_$base.zip" "$base.shx" "$base.shp" "$base.dbf" \ "${base}_text.shp" "${base}_text.shx" "${base}_text.dbf" "$file" rm -f "$file" "$base.shx" "$base.shp" "$base.dbf" "${base}_text.shp" \ "${base}_text.shx" "${base}_text.dbf" } done # Point Shapefile queue cd /var/www/acadconverter.chrismichaelis.com/uploads_Point for file in /var/www/acadconverter.chrismichaelis.com/uploads_Point/*.d*; do [[ "$file" =~ .dxf$ || "$file" =~ dwg$ ]] && { base=$(basename "$file") base=${base%.dwg} base=${base%.dxf} /var/www/acadconverter.chrismichaelis.com/bin/AutoCADConverter "$file" \ "$base.shp" point [ -e "../outputs/$base.zip" ] && rm -f "../outputs/$base.zip" zip "../outputs/$base.zip" "$base.shx" "$base.shp" "$base.dbf" \ "${base}_text.shp" "${base}_text.shx" "${base}_text.dbf" zip "../uploads_done/$(date +%s)_$base.zip" "$base.shx" "$base.shp" "$base.dbf" \

"${base}_text.shp" "${base}_text.shx" "${base}_text.dbf" "$file" rm -f "$file" "$base.shx" "$base.shp" "$base.dbf" "${base}_text.shp" \ "${base}_text.shx" "${base}_text.dbf" } done # KML queue cd /var/www/acadconverter.chrismichaelis.com/uploads_KML for file in /var/www/acadconverter.chrismichaelis.com/uploads_KML/*.d*; do [[ "$file" =~ .dxf$ || "$file" =~ dwg$ ]] && { base=$(basename "$file") base=${base%.dwg} base=${base%.dxf} /var/www/acadconverter.chrismichaelis.com/bin/AutoCADConverter "$file" "$base.kml" [ -e "../outputs/$base.zip" ] && rm -f "../outputs/$base.zip" zip "../outputs/$base.zip" "$base.kml" zip "../uploads_done/$(date +%s)_$base.zip" "$base.kml" "$file" rm -f "$file" "$base.kml" } done # Text queue cd /var/www/acadconverter.chrismichaelis.com/uploads_Text for file in /var/www/acadconverter.chrismichaelis.com/uploads_Text/*.d*; do [[ "$file" =~ .dxf$ || "$file" =~ dwg$ ]] && { base=$(basename "$file") base=${base%.dwg} base=${base%.dxf} /var/www/acadconverter.chrismichaelis.com/bin/AutoCADConverter "$file" "$base.txt" [ -e "../outputs/$base.zip" ] && rm -f "../outputs/$base.zip" zip "../outputs/$base.zip" "$base.txt" zip "../uploads_done/$(date +%s)_$base.zip" "$base.txt" "$file" rm -f "$file" "$base.txt" } done

O prprio Web site pode ser um simples pgina de upload de arquivo. Neste caso, incluir uma barra de progresso de upload seria um bom aprimoramento. Uma ferramenta de software livre chamada Ajax Upload (consulte Recursos para um link) utilizaXMLHttpRequest para ajudar a produzir uma interface de upload mais fluda. Na pgina em HTML, use a funo do jQueryconcludo para criar o carregador de arquivo quando a pgina tiver sido carregada e o formato de sada selecionado tiver sido aprovado juntamente com o arquivo transferido por upload (veja a Listagem 9). O script de upload PHP de estoque fornecido com o a ferramenta Ajax Upload usado, e no final deste script, o comando handleUpload alterado para salvar o arquivo carregado no diretrio correto para o tipo de sada desejado. Ao invs de esperar para que a tarefacron programada acontea, possvel usar a funo exec para iniciar o script e converter o arquivo. A pgina em HTML espera alguns momentos para o fim da converso, e ento direciona o visitante para o arquivo .zip gerado contendo os arquivos feitos. Listagem 9. Funo do jQuery ready() para definir o carregador de arquivo
$(document).ready(function() { var uploader = new qq.FileUploader({ 'element': $('#inputFile')[0], 'action': 'fileuploader.php', 'params': { 'outputFormat': $('#outputFormat option:selected').attr('value') }, 'onComplete': function(id, file, response) { if (!response.success) return;

// Please Wait $('#postLoader').hide() $('#postLoader').html('<img src="clock.png" height="210" width="210"><br /> Please Wait...'); $('#postLoader').slideDown(); // for IE compatibility, don't use anonymous function in setTimeout setTimeout("showDownload('" + file.replace(".dwg", "").replace(".dxf", "") + "');", 5000); return true; } }); $('#outputFormat').change(function() { uploader.setParams({ 'outputFormat': $('#outputFormat option:selected').attr('value') }); }); }); function showDownload(file) { $('#postLoader').slideUp('slow', function() { $('#postLoader').html('<img src="download.png" height="48" width="48" align="absmiddle"> <a href="outputs/' + file + '.zip">Download Ouptut</a>').slideDown(); }); }

Este cdigo simplifica consideravelmente a converso, alcanando a meta de facilitar o acesso a todos que precisarem de um arquivo convertido. Consulte a seo Recursos para um link para uma interface da Web para o conversor, ou veja a seoDownload para um cdigo fonte completo para a pgina da Web do conversor.

https://www.ibm.com/developerworks/br/opensource/library/os-autocad/index.html https://www.ibm.com/developerworks/br/opensource/library/osautocad/index.html#resources https://www.ibm.com/developerworks/br/opensource/library/osautocad/index.html#download http://pt.kioskea.net/contents/systemes/mime.php3