unknown
12 years ago
committed by
jean-pierre charras
jean-pierre charras
21 changed files with 14149 additions and 27 deletions
-
29utils/idftools/CMakeLists.txt
-
3utils/idftools/dxf2idfmain.cpp
-
842utils/idftools/idf2vrml.cpp
-
1376utils/idftools/idf_common.cpp
-
705utils/idftools/idf_common.h
-
28utils/idftools/idf_cylinder.cpp
-
149utils/idftools/idf_examples/Arduino_MEGA_2560-Rev3.emn
-
4utils/idftools/idf_examples/Arduino_MEGA_2560-Rev3.emp
-
269utils/idftools/idf_examples/idf_example.emn
-
69utils/idftools/idf_examples/idf_example.emp
-
71utils/idftools/idf_examples/test_idf2.emn
-
290utils/idftools/idf_examples/test_idf2.emp
-
295utils/idftools/idf_helpers.cpp
-
171utils/idftools/idf_helpers.h
-
2614utils/idftools/idf_outlines.cpp
-
754utils/idftools/idf_outlines.h
-
3819utils/idftools/idf_parser.cpp
-
657utils/idftools/idf_parser.h
-
24utils/idftools/idf_rect.cpp
-
1578utils/idftools/vrml_layer.cpp
-
429utils/idftools/vrml_layer.h
@ -1,29 +1,32 @@ |
|||
include_directories( |
|||
"${CMAKE_SOURCE_DIR}/include" |
|||
"${CMAKE_SOURCE_DIR}/lib_dxf" |
|||
"${CMAKE_SOURCE_DIR}/pcbnew/exporters" |
|||
"${CMAKE_SOURCE_DIR}/utils/idftools" |
|||
) |
|||
|
|||
link_directories( |
|||
"${CMAKE_BINARY_DIR}/lib_dxf" |
|||
) |
|||
) |
|||
|
|||
add_executable( idfcyl idf_cylinder.cpp ) |
|||
add_library( idf3 STATIC |
|||
idf_helpers.cpp idf_common.cpp idf_outlines.cpp |
|||
idf_parser.cpp vrml_layer.cpp ) |
|||
|
|||
add_executable( idfcyl idf_cylinder.cpp ) |
|||
add_executable( idfrect idf_rect.cpp ) |
|||
add_executable( dxf2idf dxf2idfmain.cpp dxf2idf.cpp ) |
|||
add_executable( idf2vrml idf2vrml.cpp ) |
|||
|
|||
add_executable( dxf2idf dxf2idfmain.cpp dxf2idf.cpp |
|||
"${CMAKE_SOURCE_DIR}/pcbnew/exporters/idf_common.cpp" |
|||
"${CMAKE_SOURCE_DIR}/common/richio.cpp" |
|||
) |
|||
target_link_libraries( dxf2idf lib_dxf idf3 ${wxWidgets_LIBRARIES} ) |
|||
|
|||
if( WIN32 ) |
|||
set ( LIB_GLU glu32 ) |
|||
else() |
|||
set ( LIB_GLU GLU ) |
|||
endif() |
|||
|
|||
add_dependencies( idfcyl lib-dependencies ) |
|||
add_dependencies( idfrect lib-dependencies ) |
|||
add_dependencies( dxf2idf lib-dependencies ) |
|||
target_link_libraries( idf2vrml idf3 ${LIB_GLU} ${wxWidgets_LIBRARIES} ) |
|||
|
|||
target_link_libraries( dxf2idf lib_dxf ${wxWidgets_LIBRARIES} ) |
|||
|
|||
install( TARGETS idfcyl idfrect dxf2idf |
|||
install( TARGETS idfcyl idfrect dxf2idf idf2vrml |
|||
DESTINATION ${KICAD_BIN} |
|||
COMPONENT binary ) |
|||
@ -0,0 +1,842 @@ |
|||
/*
|
|||
* This program source code file is part of KiCad, a free EDA CAD application. |
|||
* |
|||
* Copyright (C) 2014 Cirilo Bernardo |
|||
* |
|||
* This program is free software; you can redistribute it and/or |
|||
* modify it under the terms of the GNU General Public License |
|||
* as published by the Free Software Foundation; either version 2 |
|||
* of the License, or (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program; if not, you may find one here: |
|||
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|||
* or you may search the http://www.gnu.org website for the version 2 license,
|
|||
* or you may write to the Free Software Foundation, Inc., |
|||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA |
|||
*/ |
|||
|
|||
/*
|
|||
* This program takes an IDF base name, loads the board outline |
|||
* and component outine files, and creates a single VRML file. |
|||
* The VRML file can be used to visually verify the IDF files |
|||
* before sending them to a mechanical designer. The output scale |
|||
* is 10:1; this scale was chosen because VRML was originally |
|||
* intended to describe large virtual worlds and rounding errors |
|||
* would be more likely if we used a 1:1 scale. |
|||
*/ |
|||
|
|||
#include <iostream>
|
|||
#include <iomanip>
|
|||
#include <fstream>
|
|||
#include <string>
|
|||
#include <sstream>
|
|||
#include <cmath>
|
|||
#include <cstdio>
|
|||
#include <cerrno>
|
|||
#include <list>
|
|||
#include <utility>
|
|||
#include <clocale>
|
|||
#include <vector>
|
|||
#include <cstdlib>
|
|||
#include <cstring>
|
|||
#include <libgen.h>
|
|||
#include <unistd.h>
|
|||
|
|||
#include <idf_helpers.h>
|
|||
#include <idf_common.h>
|
|||
#include <idf_parser.h>
|
|||
#include <vrml_layer.h>
|
|||
|
|||
#ifndef MIN_ANG
|
|||
#define MIN_ANG 0.01
|
|||
#endif
|
|||
|
|||
extern char* optarg; |
|||
extern int optopt; |
|||
|
|||
using namespace std; |
|||
|
|||
#define CLEANUP do { \
|
|||
setlocale( LC_ALL, "C" ); \ |
|||
} while( 0 ); |
|||
|
|||
// define colors
|
|||
struct VRML_COLOR |
|||
{ |
|||
double diff[3]; |
|||
double emis[3]; |
|||
double spec[3]; |
|||
double ambi; |
|||
double tran; |
|||
double shin; |
|||
}; |
|||
|
|||
struct VRML_IDS |
|||
{ |
|||
int colorIndex; |
|||
std::string objectName; |
|||
bool used; |
|||
bool bottom; |
|||
double dX, dY, dZ, dA; |
|||
|
|||
VRML_IDS() |
|||
{ |
|||
colorIndex = 0; |
|||
used = false; |
|||
bottom = false; |
|||
dX = 0.0; |
|||
dY = 0.0; |
|||
dZ = 0.0; |
|||
dA = 0.0; |
|||
} |
|||
}; |
|||
|
|||
#define NCOLORS 7
|
|||
VRML_COLOR colors[NCOLORS] = { \ |
|||
{ 0, 0.82, 0.247, 0, 0, 0, 0, 0.82, 0.247, 0.9, 0, 0.1}, \ |
|||
{ 1, 0, 0, 1, 0, 0, 1, 0, 0, 0.9, 0, 0.1}, \ |
|||
{ 0.659, 0, 0.463, 0, 0, 0, 0.659, 0, 0.463, 0.9, 0, 0.1}, \ |
|||
{ 0.659, 0.294, 0, 0, 0, 0, 0.659, 0.294, 0, 0.9, 0, 0.1}, \ |
|||
{ 0, 0.918, 0.659, 0, 0, 0, 0, 0.918, 0.659, 0.9, 0, 0.1}, \ |
|||
{ 0.808, 0.733 , 0.071, 0, 0, 0, 0.808, 0.733 , 0.071, 0.9, 0, 0.1}, \ |
|||
{ 0.102, 1, 0.984, 0, 0, 0, 0.102, 1, 0.984, 0.9, 0, 0.1} |
|||
}; |
|||
|
|||
bool WriteHeader( IDF3_BOARD& board, std::ofstream& file ); |
|||
bool MakeBoard( IDF3_BOARD& board, std::ofstream& file ); |
|||
bool MakeComponents( IDF3_BOARD& board, std::ofstream& file, bool compact ); |
|||
bool PopulateVRML( VRML_LAYER& model, const std::list< IDF_OUTLINE* >* items, bool bottom, |
|||
double scale, double dX = 0.0, double dY = 0.0, double angle = 0.0 ); |
|||
bool AddSegment( VRML_LAYER& model, IDF_SEGMENT* seg, int icont, int iseg ); |
|||
bool WriteTriangles( std::ofstream& file, VRML_IDS* vID, VRML_LAYER* layer, bool plane, |
|||
bool top, double top_z, double bottom_z, int precision, bool compact ); |
|||
inline void TransformPoint( IDF_SEGMENT& seg, double frac, bool bottom, |
|||
double dX, double dY, double angle ); |
|||
VRML_IDS* GetColor( std::map<std::string, VRML_IDS*>& cmap, |
|||
int& index, const std::string& uid ); |
|||
|
|||
|
|||
void PrintUsage( void ) |
|||
{ |
|||
cout << "-\nUsage: idf2vrml -f input_file.emn -s scale_factor -k\n"; |
|||
cout << "flags: -k: produce KiCad-firendly VRML output; default is compact VRML\n-\n"; |
|||
cout << "example to produce a model for use by KiCad: idf2vrml -f input.emn -s 0.3937008 -k\n\n"; |
|||
return; |
|||
} |
|||
|
|||
int main( int argc, char **argv ) |
|||
{ |
|||
// IDF implicitly requires the C locale
|
|||
setlocale( LC_ALL, "C" ); |
|||
|
|||
// Essential inputs:
|
|||
// 1. IDF file
|
|||
// 2. Output scale: internal IDF units are mm, so 1 = 1mm per VRML unit,
|
|||
// 0.1 = 1cm per VRML unit, 0.01 = 1m per VRML unit,
|
|||
// 1/25.4 = 1in per VRML unit, 1/2.54 = 0.1in per VRML unit (KiCad model)
|
|||
// 3. KiCad-friendly output (do not reuse features via DEF+USE)
|
|||
// Render each component to VRML; if the user wants
|
|||
// a KiCad friendly output then we must avoid DEF+USE;
|
|||
// otherwise we employ DEF+USE to minimize file size
|
|||
|
|||
std::string inputFilename; |
|||
double scaleFactor = 1.0; |
|||
bool compact = true; |
|||
int ichar; |
|||
|
|||
while( ( ichar = getopt( argc, argv, ":f:s:k" ) ) != -1 ) |
|||
{ |
|||
switch( ichar ) |
|||
{ |
|||
case 'f': |
|||
inputFilename = optarg; |
|||
break; |
|||
|
|||
case 's': |
|||
do |
|||
{ |
|||
errno = 0; |
|||
char* cp = NULL; |
|||
scaleFactor = strtod( optarg, &cp ); |
|||
|
|||
if( errno || cp == optarg ) |
|||
{ |
|||
cerr << "* invalid scale factor: '" << optarg << "'\n"; |
|||
return -1; |
|||
} |
|||
|
|||
if( scaleFactor < 0.001 || scaleFactor > 10 ) |
|||
{ |
|||
cerr << "* scale factor out of range (" << scaleFactor << "); range is 0.001 to 10.0\n"; |
|||
return -1; |
|||
} |
|||
|
|||
} while( 0 ); |
|||
break; |
|||
|
|||
case 'k': |
|||
compact = false; |
|||
break; |
|||
|
|||
case ':': |
|||
cerr << "* Missing parameter to option '-" << ((char) optopt) << "'\n"; |
|||
PrintUsage(); |
|||
return -1; |
|||
break; |
|||
|
|||
default: |
|||
cerr << "* Unexpected option: '-"; |
|||
|
|||
if( ichar == '?' ) |
|||
cerr << ((char) optopt) << "'\n"; |
|||
else |
|||
cerr << ((char) ichar) << "'\n"; |
|||
|
|||
PrintUsage(); |
|||
return -1; |
|||
break; |
|||
} |
|||
} |
|||
|
|||
if( inputFilename.empty() ) |
|||
{ |
|||
cerr << "* no IDF filename supplied\n"; |
|||
PrintUsage(); |
|||
return -1; |
|||
} |
|||
|
|||
IDF3_BOARD pcb( IDF3::CAD_ELEC ); |
|||
|
|||
cout << "** Reading file: " << inputFilename << "\n"; |
|||
|
|||
if( !pcb.ReadFile( FROM_UTF8( inputFilename.c_str() ) ) ) |
|||
{ |
|||
CLEANUP; |
|||
cerr << "* Could not read file: " << inputFilename << "\n"; |
|||
return -1; |
|||
} |
|||
|
|||
// set the scale and output precision ( scale 1 == precision 5)
|
|||
pcb.SetUserScale( scaleFactor ); |
|||
|
|||
if( scaleFactor < 0.01 ) |
|||
pcb.SetUserPrecision( 8 ); |
|||
else if( scaleFactor < 0.1 ) |
|||
pcb.SetUserPrecision( 7 ); |
|||
else if( scaleFactor < 1.0 ) |
|||
pcb.SetUserPrecision( 6 ); |
|||
else if( scaleFactor < 10.0 ) |
|||
pcb.SetUserPrecision( 5 ); |
|||
else |
|||
pcb.SetUserPrecision( 4 ); |
|||
|
|||
// Create the VRML file and write the header
|
|||
char* bnp = (char*) malloc( inputFilename.size() + 1 ); |
|||
strcpy( bnp, inputFilename.c_str() ); |
|||
|
|||
std::string fname = basename( bnp ); |
|||
free( bnp ); |
|||
std::string::iterator itf = fname.end(); |
|||
*(--itf) = 'l'; |
|||
*(--itf) = 'r'; |
|||
*(--itf) = 'w'; |
|||
|
|||
cout << "Writing file: '" << fname << "'\n"; |
|||
|
|||
std::ofstream ofile; |
|||
ofile.open( fname.c_str(), std::ios_base::out ); |
|||
|
|||
ofile << fixed; // do not use exponents in VRML output
|
|||
WriteHeader( pcb, ofile ); |
|||
|
|||
// STEP 1: Render the PCB alone
|
|||
MakeBoard( pcb, ofile ); |
|||
|
|||
// STEP 2: Render the components
|
|||
MakeComponents( pcb, ofile, compact ); |
|||
|
|||
ofile << "]\n}\n"; |
|||
ofile.close(); |
|||
|
|||
// restore the locale
|
|||
setlocale( LC_ALL, "" ); |
|||
return 0; |
|||
} |
|||
|
|||
|
|||
bool WriteHeader( IDF3_BOARD& board, std::ofstream& file ) |
|||
{ |
|||
std::string bname = board.GetBoardName(); |
|||
|
|||
if( bname.empty() ) |
|||
{ |
|||
bname = "BoardWithNoName"; |
|||
} |
|||
else |
|||
{ |
|||
std::string::iterator ss = bname.begin(); |
|||
std::string::iterator se = bname.end(); |
|||
|
|||
while( ss != se ) |
|||
{ |
|||
if( *ss == '/' || *ss == ' ' || *ss == ':' ) |
|||
*ss = '_'; |
|||
|
|||
++ss; |
|||
} |
|||
} |
|||
|
|||
file << "#VRML V2.0 utf8\n\n"; |
|||
file << "WorldInfo {\n"; |
|||
file << " title \"" << bname << "\"\n}\n\n"; |
|||
file << "Transform {\n"; |
|||
file << "children [\n"; |
|||
|
|||
return !file.fail(); |
|||
} |
|||
|
|||
|
|||
bool MakeBoard( IDF3_BOARD& board, std::ofstream& file ) |
|||
{ |
|||
VRML_LAYER vpcb; |
|||
|
|||
if( board.GetBoardOutlinesSize() < 1 ) |
|||
{ |
|||
ERROR_IDF << "\n"; |
|||
cerr << "* Cannot proceed; no board outline in IDF object\n"; |
|||
return false; |
|||
} |
|||
|
|||
double scale = board.GetUserScale(); |
|||
|
|||
// set the arc parameters according to output scale
|
|||
int tI; |
|||
double tMin, tMax; |
|||
vpcb.GetArcParams( tI, tMin, tMax ); |
|||
vpcb.SetArcParams( tI, tMin * scale, tMax * scale ); |
|||
|
|||
if( !PopulateVRML( vpcb, board.GetBoardOutline()->GetOutlines(), false, board.GetUserScale() ) ) |
|||
{ |
|||
return false; |
|||
} |
|||
|
|||
vpcb.EnsureWinding( 0, false ); |
|||
|
|||
int nvcont = vpcb.GetNContours(); |
|||
|
|||
while( nvcont > 0 ) |
|||
vpcb.EnsureWinding( nvcont--, true ); |
|||
|
|||
// Add the drill holes
|
|||
const std::list<IDF_DRILL_DATA*>* drills = &board.GetBoardDrills(); |
|||
|
|||
std::list<IDF_DRILL_DATA*>::const_iterator sd = drills->begin(); |
|||
std::list<IDF_DRILL_DATA*>::const_iterator ed = drills->end(); |
|||
|
|||
while( sd != ed ) |
|||
{ |
|||
vpcb.AddCircle( (*sd)->GetDrillXPos() * scale, (*sd)->GetDrillYPos() * scale, |
|||
(*sd)->GetDrillDia() * scale / 2.0, true ); |
|||
++sd; |
|||
} |
|||
|
|||
std::map< std::string, IDF3_COMPONENT* >*const comp = board.GetComponents(); |
|||
std::map< std::string, IDF3_COMPONENT* >::const_iterator sc = comp->begin(); |
|||
std::map< std::string, IDF3_COMPONENT* >::const_iterator ec = comp->end(); |
|||
|
|||
while( sc != ec ) |
|||
{ |
|||
drills = sc->second->GetDrills(); |
|||
sd = drills->begin(); |
|||
ed = drills->end(); |
|||
|
|||
while( sd != ed ) |
|||
{ |
|||
vpcb.AddCircle( (*sd)->GetDrillXPos() * scale, (*sd)->GetDrillYPos() * scale, |
|||
(*sd)->GetDrillDia() * scale / 2.0, true ); |
|||
++sd; |
|||
} |
|||
|
|||
++sc; |
|||
} |
|||
|
|||
// tesselate and write out
|
|||
vpcb.Tesselate( NULL ); |
|||
|
|||
double thick = board.GetBoardThickness() / 2.0 * scale; |
|||
|
|||
VRML_IDS tvid; |
|||
tvid.colorIndex = 0; |
|||
|
|||
WriteTriangles( file, &tvid, &vpcb, false, false, |
|||
thick, -thick, board.GetUserPrecision(), false ); |
|||
|
|||
return true; |
|||
} |
|||
|
|||
bool PopulateVRML( VRML_LAYER& model, const std::list< IDF_OUTLINE* >* items, bool bottom, double scale, |
|||
double dX, double dY, double angle ) |
|||
{ |
|||
// empty outlines are not unusual so we fail quietly
|
|||
if( items->size() < 1 ) |
|||
return false; |
|||
|
|||
int nvcont = 0; |
|||
int iseg = 0; |
|||
|
|||
std::list< IDF_OUTLINE* >::const_iterator scont = items->begin(); |
|||
std::list< IDF_OUTLINE* >::const_iterator econt = items->end(); |
|||
std::list<IDF_SEGMENT*>::iterator sseg; |
|||
std::list<IDF_SEGMENT*>::iterator eseg; |
|||
|
|||
IDF_SEGMENT lseg; |
|||
|
|||
while( scont != econt ) |
|||
{ |
|||
nvcont = model.NewContour(); |
|||
|
|||
if( nvcont < 0 ) |
|||
{ |
|||
ERROR_IDF << "\n"; |
|||
cerr << "* cannot create an outline\n"; |
|||
return false; |
|||
} |
|||
|
|||
if( (*scont)->size() < 1 ) |
|||
{ |
|||
ERROR_IDF << "invalid contour: no vertices\n"; |
|||
return false; |
|||
} |
|||
|
|||
sseg = (*scont)->begin(); |
|||
eseg = (*scont)->end(); |
|||
|
|||
iseg = 0; |
|||
while( sseg != eseg ) |
|||
{ |
|||
lseg = **sseg; |
|||
TransformPoint( lseg, scale, bottom, dX, dY, angle ); |
|||
|
|||
if( !AddSegment( model, &lseg, nvcont, iseg ) ) |
|||
return false; |
|||
|
|||
++iseg; |
|||
++sseg; |
|||
} |
|||
|
|||
++scont; |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
|
|||
bool AddSegment( VRML_LAYER& model, IDF_SEGMENT* seg, int icont, int iseg ) |
|||
{ |
|||
// note: in all cases we must add all but the last point in the segment
|
|||
// to avoid redundant points
|
|||
|
|||
if( seg->angle != 0.0 ) |
|||
{ |
|||
if( seg->IsCircle() ) |
|||
{ |
|||
if( iseg != 0 ) |
|||
{ |
|||
ERROR_IDF << "adding a circle to an existing vertex list\n"; |
|||
return false; |
|||
} |
|||
|
|||
return model.AppendCircle( seg->center.x, seg->center.y, seg->radius, icont ); |
|||
} |
|||
else |
|||
{ |
|||
return model.AppendArc( seg->center.x, seg->center.y, seg->radius, |
|||
seg->offsetAngle, seg->angle, icont ); |
|||
} |
|||
} |
|||
|
|||
if( !model.AddVertex( icont, seg->startPoint.x, seg->startPoint.y ) ) |
|||
return false; |
|||
|
|||
return true; |
|||
} |
|||
|
|||
|
|||
bool WriteTriangles( std::ofstream& file, VRML_IDS* vID, VRML_LAYER* layer, bool plane, |
|||
bool top, double top_z, double bottom_z, int precision, bool compact ) |
|||
{ |
|||
if( vID == NULL || layer == NULL ) |
|||
return false; |
|||
|
|||
file << "Transform {\n"; |
|||
|
|||
if( compact && !vID->objectName.empty() ) |
|||
{ |
|||
file << "translation " << setprecision( precision ) << vID->dX; |
|||
file << " " << vID->dY << " "; |
|||
|
|||
if( vID->bottom ) |
|||
{ |
|||
file << -vID->dZ << "\n"; |
|||
|
|||
double tx, ty; |
|||
|
|||
// calculate the rotation axis and angle
|
|||
tx = cos( M_PI2 - vID->dA / 2.0 ); |
|||
ty = sin( M_PI2 - vID->dA / 2.0 ); |
|||
|
|||
file << "rotation " << setprecision( precision ); |
|||
file << tx << " " << ty << " 0 "; |
|||
file << setprecision(5) << M_PI << "\n"; |
|||
} |
|||
else |
|||
{ |
|||
file << vID->dZ << "\n"; |
|||
file << "rotation 0 0 1 " << setprecision(5) << vID->dA << "\n"; |
|||
} |
|||
|
|||
file << "children [\n"; |
|||
|
|||
if( vID->used ) |
|||
{ |
|||
file << "USE " << vID->objectName << "\n"; |
|||
file << "]\n"; |
|||
file << "}\n"; |
|||
return true; |
|||
} |
|||
|
|||
file << "DEF " << vID->objectName << " Transform {\n"; |
|||
|
|||
if( !plane && top_z <= bottom_z ) |
|||
{ |
|||
// the height specification is faulty; make the component
|
|||
// a bright red to highlight it
|
|||
vID->colorIndex = 1; |
|||
// we don't know the scale, but 5 units is huge in most situations
|
|||
top_z = bottom_z + 5.0; |
|||
} |
|||
|
|||
} |
|||
|
|||
VRML_COLOR* color = &colors[vID->colorIndex]; |
|||
|
|||
vID->used = true; |
|||
|
|||
file << "children [\n"; |
|||
file << "Group {\n"; |
|||
file << "children [\n"; |
|||
file << "Shape {\n"; |
|||
file << "appearance Appearance {\n"; |
|||
file << "material Material {\n"; |
|||
|
|||
// material definition
|
|||
file << "diffuseColor " << setprecision(3) << color->diff[0] << " "; |
|||
file << color->diff[1] << " " << color->diff[2] << "\n"; |
|||
file << "specularColor " << color->spec[0] << " " << color->spec[1]; |
|||
file << " " << color->spec[2] << "\n"; |
|||
file << "emissiveColor " << color->emis[0] << " " << color->emis[1]; |
|||
file << " " << color->emis[2] << "\n"; |
|||
file << "ambientIntensity " << color->ambi << "\n"; |
|||
file << "transparency " << color->tran << "\n"; |
|||
file << "shininess " << color->shin << "\n"; |
|||
|
|||
file << "}\n"; |
|||
file << "}\n"; |
|||
file << "geometry IndexedFaceSet {\n"; |
|||
file << "solid TRUE\n"; |
|||
file << "coord Coordinate {\n"; |
|||
file << "point [\n"; |
|||
|
|||
// XXX: TODO: check return values of Write() routines; they may fail
|
|||
// even though the stream is good (bad internal data)
|
|||
|
|||
// Coordinates (vertices)
|
|||
if( plane ) |
|||
{ |
|||
if( ! layer->WriteVertices( top_z, file, precision ) ) |
|||
{ |
|||
cerr << "* errors writing planar vertices to " << vID->objectName << "\n"; |
|||
cerr << "** " << layer->GetError() << "\n"; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
if( ! layer->Write3DVertices( top_z, bottom_z, file, precision ) ) |
|||
{ |
|||
cerr << "* errors writing 3D vertices to " << vID->objectName << "\n"; |
|||
cerr << "** " << layer->GetError() << "\n"; |
|||
} |
|||
} |
|||
|
|||
file << "\n"; |
|||
|
|||
file << "]\n"; |
|||
file << "}\n"; |
|||
file << "coordIndex [\n"; |
|||
|
|||
// Indices
|
|||
if( plane ) |
|||
layer->WriteIndices( top, file ); |
|||
else |
|||
layer->Write3DIndices( file ); |
|||
|
|||
file << "\n"; |
|||
file << "]\n"; |
|||
file << "}\n"; |
|||
file << "}\n"; |
|||
file << "]\n"; |
|||
file << "}\n"; |
|||
file << "]\n"; |
|||
file << "}\n"; |
|||
|
|||
if( compact && !vID->objectName.empty() ) |
|||
{ |
|||
file << "]\n"; |
|||
file << "}\n"; |
|||
} |
|||
|
|||
return !file.fail(); |
|||
} |
|||
|
|||
inline void TransformPoint( IDF_SEGMENT& seg, double frac, bool bottom, |
|||
double dX, double dY, double angle ) |
|||
{ |
|||
dX *= frac; |
|||
dY *= frac; |
|||
|
|||
if( bottom ) |
|||
{ |
|||
// mirror points on the Y axis
|
|||
seg.startPoint.x = -seg.startPoint.x; |
|||
seg.endPoint.x = -seg.endPoint.x; |
|||
seg.center.x = -seg.center.x; |
|||
angle = -angle; |
|||
} |
|||
|
|||
seg.startPoint.x *= frac; |
|||
seg.startPoint.y *= frac; |
|||
seg.endPoint.x *= frac; |
|||
seg.endPoint.y *= frac; |
|||
seg.center.x *= frac; |
|||
seg.center.y *= frac; |
|||
|
|||
double tsin = 0.0; |
|||
double tcos = 0.0; |
|||
|
|||
if( angle > MIN_ANG || angle < -MIN_ANG ) |
|||
{ |
|||
double ta = angle * M_PI / 180.0; |
|||
double tx, ty; |
|||
|
|||
tsin = sin( ta ); |
|||
tcos = cos( ta ); |
|||
|
|||
tx = seg.startPoint.x * tcos - seg.startPoint.y * tsin; |
|||
ty = seg.startPoint.x * tsin + seg.startPoint.y * tcos; |
|||
seg.startPoint.x = tx; |
|||
seg.startPoint.y = ty; |
|||
|
|||
tx = seg.endPoint.x * tcos - seg.endPoint.y * tsin; |
|||
ty = seg.endPoint.x * tsin + seg.endPoint.y * tcos; |
|||
seg.endPoint.x = tx; |
|||
seg.endPoint.y = ty; |
|||
|
|||
if( seg.angle != 0 ) |
|||
{ |
|||
tx = seg.center.x * tcos - seg.center.y * tsin; |
|||
ty = seg.center.x * tsin + seg.center.y * tcos; |
|||
seg.center.x = tx; |
|||
seg.center.y = ty; |
|||
} |
|||
} |
|||
|
|||
seg.startPoint.x += dX; |
|||
seg.startPoint.y += dY; |
|||
seg.endPoint.x += dX; |
|||
seg.endPoint.y += dY; |
|||
seg.center.x += dX; |
|||
seg.center.y += dY; |
|||
|
|||
if( seg.angle != 0 ) |
|||
{ |
|||
seg.radius *= frac; |
|||
|
|||
if( bottom ) |
|||
{ |
|||
if( !seg.IsCircle() ) |
|||
{ |
|||
seg.angle = -seg.angle; |
|||
if( seg.offsetAngle > 0.0 ) |
|||
seg.offsetAngle = 180 - seg.offsetAngle; |
|||
else |
|||
seg.offsetAngle = -seg.offsetAngle - 180; |
|||
} |
|||
} |
|||
|
|||
if( angle > MIN_ANG || angle < -MIN_ANG ) |
|||
seg.offsetAngle += angle; |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
bool MakeComponents( IDF3_BOARD& board, std::ofstream& file, bool compact ) |
|||
{ |
|||
int cidx = 2; // color index; start at 2 since 0,1 are special (board, NOGEOM_NOPART)
|
|||
|
|||
VRML_LAYER vpcb; |
|||
|
|||
double scale = board.GetUserScale(); |
|||
double thick = board.GetBoardThickness() / 2.0; |
|||
|
|||
// set the arc parameters according to output scale
|
|||
int tI; |
|||
double tMin, tMax; |
|||
vpcb.GetArcParams( tI, tMin, tMax ); |
|||
vpcb.SetArcParams( tI, tMin * scale, tMax * scale ); |
|||
|
|||
// Add the component outlines
|
|||
const std::map< std::string, IDF3_COMPONENT* >*const comp = board.GetComponents(); |
|||
std::map< std::string, IDF3_COMPONENT* >::const_iterator sc = comp->begin(); |
|||
std::map< std::string, IDF3_COMPONENT* >::const_iterator ec = comp->end(); |
|||
|
|||
std::list< IDF3_COMP_OUTLINE_DATA* >::const_iterator so; |
|||
std::list< IDF3_COMP_OUTLINE_DATA* >::const_iterator eo; |
|||
|
|||
double vX, vY, vA; |
|||
double tX, tY, tZ, tA; |
|||
double top, bot; |
|||
bool bottom; |
|||
IDF3::IDF_LAYER lyr; |
|||
|
|||
std::map< std::string, VRML_IDS*> cmap; // map colors by outline UID
|
|||
VRML_IDS* vcp; |
|||
|
|||
while( sc != ec ) |
|||
{ |
|||
sc->second->GetPosition( vX, vY, vA, lyr ); |
|||
|
|||
if( lyr == IDF3::LYR_BOTTOM ) |
|||
bottom = true; |
|||
else |
|||
bottom = false; |
|||
|
|||
so = sc->second->GetOutlinesData()->begin(); |
|||
eo = sc->second->GetOutlinesData()->end(); |
|||
|
|||
while( so != eo ) |
|||
{ |
|||
(*so)->GetOffsets( tX, tY, tZ, tA ); |
|||
tX += vX; |
|||
tY += vY; |
|||
tA += vA; |
|||
|
|||
vcp = GetColor( cmap, cidx, ((IDF3_COMP_OUTLINE*)((*so)->GetOutline()))->GetUID() ); |
|||
|
|||
if( !compact ) |
|||
{ |
|||
if( !PopulateVRML( vpcb, (*so)->GetOutline()->GetOutlines(), bottom, |
|||
board.GetUserScale(), tX, tY, tA ) ) |
|||
{ |
|||
return false; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
if( !vcp->used && !PopulateVRML( vpcb, (*so)->GetOutline()->GetOutlines(), false, |
|||
board.GetUserScale() ) ) |
|||
{ |
|||
return false; |
|||
} |
|||
|
|||
vcp->dX = tX * scale; |
|||
vcp->dY = tY * scale; |
|||
vcp->dZ = tZ * scale; |
|||
vcp->dA = tA * M_PI / 180.0; |
|||
} |
|||
|
|||
if( !compact || !vcp->used ) |
|||
{ |
|||
vpcb.EnsureWinding( 0, false ); |
|||
vpcb.Tesselate( NULL ); |
|||
} |
|||
|
|||
if( !compact ) |
|||
{ |
|||
if( bottom ) |
|||
{ |
|||
top = -thick - tZ; |
|||
bot = (top - (*so)->GetOutline()->GetThickness() ) * scale; |
|||
top *= scale; |
|||
} |
|||
else |
|||
{ |
|||
bot = thick + tZ; |
|||
top = (bot + (*so)->GetOutline()->GetThickness() ) * scale; |
|||
bot *= scale; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
bot = thick; |
|||
top = (bot + (*so)->GetOutline()->GetThickness() ) * scale; |
|||
bot *= scale; |
|||
} |
|||
|
|||
vcp = GetColor( cmap, cidx, ((IDF3_COMP_OUTLINE*)((*so)->GetOutline()))->GetUID() ); |
|||
vcp->bottom = bottom; |
|||
|
|||
WriteTriangles( file, vcp, &vpcb, false, |
|||
false, top, bot, board.GetUserPrecision(), compact ); |
|||
|
|||
vpcb.Clear(); |
|||
++so; |
|||
} |
|||
|
|||
++sc; |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
|
|||
VRML_IDS* GetColor( std::map<std::string, VRML_IDS*>& cmap, int& index, const std::string& uid ) |
|||
{ |
|||
static int refnum = 0; |
|||
|
|||
if( index < 2 ) |
|||
index = 2; // 0 and 1 are special (BOARD, UID=NOGEOM_NOPART)
|
|||
|
|||
std::map<std::string, VRML_IDS*>::iterator cit = cmap.find( uid ); |
|||
|
|||
if( cit == cmap.end() ) |
|||
{ |
|||
VRML_IDS* id = new VRML_IDS; |
|||
|
|||
if( !uid.compare( "NOGEOM_NOPART" ) ) |
|||
id->colorIndex = 1; |
|||
else |
|||
id->colorIndex = index++; |
|||
|
|||
std::ostringstream ostr; |
|||
ostr << "OBJECTn" << refnum++; |
|||
id->objectName = ostr.str(); |
|||
|
|||
cout << "* " << ostr.str() << " = '" << uid << "'\n"; |
|||
|
|||
cmap.insert( std::pair<std::string, VRML_IDS*>(uid, id) ); |
|||
|
|||
if( index >= NCOLORS ) |
|||
index = 2; |
|||
|
|||
return id; |
|||
} |
|||
|
|||
return cit->second; |
|||
} |
|||
1376
utils/idftools/idf_common.cpp
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,705 @@ |
|||
/** |
|||
* @file idf_common.h |
|||
*/ |
|||
|
|||
/* |
|||
* This program source code file is part of KiCad, a free EDA CAD application. |
|||
* |
|||
* Copyright (C) 2013-2014 Cirilo Bernardo |
|||
* |
|||
* This program is free software; you can redistribute it and/or |
|||
* modify it under the terms of the GNU General Public License |
|||
* as published by the Free Software Foundation; either version 2 |
|||
* of the License, or (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program; if not, you may find one here: |
|||
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html |
|||
* or you may search the http://www.gnu.org website for the version 2 license, |
|||
* or you may write to the Free Software Foundation, Inc., |
|||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA |
|||
*/ |
|||
|
|||
#ifndef IDF_COMMON_H |
|||
#define IDF_COMMON_H |
|||
|
|||
#include <list> |
|||
#include <fstream> |
|||
#include <exception> |
|||
#include <string> |
|||
|
|||
#ifndef M_PI |
|||
#define M_PI 3.1415926535897932384626433832795028841 |
|||
#endif |
|||
|
|||
#ifndef M_PI2 |
|||
#define M_PI2 ( M_PI / 2.0 ) |
|||
#endif |
|||
|
|||
#ifndef M_PI4 |
|||
#define M_PI4 ( M_PI / 4.0 ) |
|||
#endif |
|||
|
|||
// differences in angle smaller than MIN_ANG are considered equal |
|||
#define MIN_ANG (0.01) |
|||
|
|||
class IDF_POINT; |
|||
class IDF_SEGMENT; |
|||
class IDF_DRILL_DATA; |
|||
class IDF_OUTLINE; |
|||
class IDF_LIB; |
|||
|
|||
|
|||
struct IDF_ERROR : std::exception |
|||
{ |
|||
std::string message; |
|||
|
|||
IDF_ERROR( const char* aSourceFile, |
|||
const char* aSourceMethod, |
|||
int aSourceLine, |
|||
const std::string& aMessage ) throw(); |
|||
|
|||
virtual ~IDF_ERROR() throw(); |
|||
|
|||
virtual const char* what() const throw(); |
|||
}; |
|||
|
|||
|
|||
namespace IDF3 { |
|||
|
|||
/** |
|||
* ENUM FILE_STATE |
|||
* represents state values for the IDF parser's input |
|||
*/ |
|||
enum FILE_STATE |
|||
{ |
|||
FILE_START = 0, // no data has been read; expecting .HEADER |
|||
FILE_HEADER, // header has been read; expecting .BOARD_OUTLINE |
|||
FILE_OUTLINE, // board outline has been read; most sections can be accepted |
|||
FILE_PLACEMENT, // placement has been read; no further sections can be accepted |
|||
FILE_INVALID, // file is invalid |
|||
FILE_ERROR // other errors while processing the file |
|||
}; |
|||
|
|||
/** |
|||
* ENUM KEY_OWNER |
|||
* represents the type of CAD which has ownership an object |
|||
*/ |
|||
enum KEY_OWNER |
|||
{ |
|||
UNOWNED = 0, //< either MCAD or ECAD may modify a feature |
|||
MCAD, //< only MCAD may modify a feature |
|||
ECAD //< only ECAD may modify a feature |
|||
}; |
|||
|
|||
/** |
|||
* ENUM KEY_HOLETYPE |
|||
* represents the purpose of an IDF hole |
|||
*/ |
|||
enum KEY_HOLETYPE |
|||
{ |
|||
PIN = 0, //< drill hole is for a pin |
|||
VIA, //< drill hole is for a via |
|||
MTG, //< drill hole is for mounting |
|||
TOOL, //< drill hole is for tooling |
|||
OTHER //< user has specified a custom type |
|||
}; |
|||
|
|||
/** |
|||
* ENUM KEY_PLATING |
|||
* represents the plating condition of a hole |
|||
*/ |
|||
enum KEY_PLATING |
|||
{ |
|||
PTH = 0, //< Plate-Through Hole |
|||
NPTH //< Non-Plate-Through Hole |
|||
}; |
|||
|
|||
/** |
|||
* ENUM KEY_REFDES |
|||
* represents a component's Reference Designator |
|||
*/ |
|||
enum KEY_REFDES |
|||
{ |
|||
BOARD = 0, //< feature is associated with the board |
|||
NOREFDES, //< feature is associated with a component with no RefDes |
|||
PANEL, //< feature is associated with an IDF panel |
|||
REFDES //< reference designator as assigned by the CAD software |
|||
}; |
|||
|
|||
/** |
|||
* ENUM CAD_TYPE |
|||
* represents the class of CAD program which is opening or modifying a file |
|||
*/ |
|||
enum CAD_TYPE |
|||
{ |
|||
CAD_ELEC = 0, //< An Electrical CAD is opening/modifying the file |
|||
CAD_MECH, //< A Mechanical CAD is opening/modifying the file |
|||
CAD_INVALID |
|||
}; |
|||
|
|||
/** |
|||
* ENUM IDF_LAYER |
|||
* represents the various IDF layer classes and groupings |
|||
*/ |
|||
enum IDF_LAYER |
|||
{ |
|||
LYR_TOP = 0, |
|||
LYR_BOTTOM, |
|||
LYR_BOTH, |
|||
LYR_INNER, |
|||
LYR_ALL, |
|||
LYR_INVALID |
|||
}; |
|||
|
|||
/** |
|||
* ENUM OUTLINE_TYPE |
|||
* identifies the class of outline |
|||
*/ |
|||
enum OUTLINE_TYPE |
|||
{ |
|||
OTLN_BOARD = 0, |
|||
OTLN_OTHER, |
|||
OTLN_PLACE, |
|||
OTLN_ROUTE, |
|||
OTLN_PLACE_KEEPOUT, |
|||
OTLN_ROUTE_KEEPOUT, |
|||
OTLN_VIA_KEEPOUT, |
|||
OTLN_GROUP_PLACE, |
|||
OTLN_COMPONENT, |
|||
OTLN_INVALID |
|||
}; |
|||
|
|||
/** |
|||
* ENUM COMP_TYPE |
|||
* identifies whether a component is a mechanical or electrical part |
|||
*/ |
|||
enum COMP_TYPE |
|||
{ |
|||
COMP_ELEC = 0, //< Component library object is an electrical part |
|||
COMP_MECH, //< Component library object is a mechanical part |
|||
COMP_INVALID |
|||
}; |
|||
|
|||
/** |
|||
* ENUM IDF_UNIT |
|||
* represents the native unit of the board and of component outlines |
|||
*/ |
|||
enum IDF_UNIT |
|||
{ |
|||
UNIT_MM = 0, //< Units in the file are in millimeters |
|||
UNIT_THOU, //< Units in the file are in mils (aka thou) |
|||
UNIT_INVALID |
|||
}; |
|||
|
|||
/** |
|||
* ENUM IDF_PLACEMENT |
|||
* represents the placement status of a component |
|||
*/ |
|||
enum IDF_PLACEMENT |
|||
{ |
|||
PS_UNPLACED = 0, //< component location on the board has not been specified |
|||
PS_PLACED, //< component location has been specified and may be modified by ECAD or MCAD |
|||
PS_MCAD, //< component location has been specified and may only be modified by MCAD |
|||
PS_ECAD, //< component location has been specified and may only be modified by ECAD |
|||
PS_INVALID |
|||
}; |
|||
|
|||
/** |
|||
* Function CalcAngleRad |
|||
* calculates the angle (radians) between the horizon and the segment aStartPoint to aEndPoint |
|||
* |
|||
* @param aStartPoint is the start point of a line segment |
|||
* @param aEndPoint is the end point of a line segment |
|||
* |
|||
* @return double: the angle in radians |
|||
*/ |
|||
double CalcAngleRad( const IDF_POINT& aStartPoint, const IDF_POINT& aEndPoint ); |
|||
|
|||
|
|||
/** |
|||
* Function CalcAngleDeg |
|||
* calculates the angle (degrees) between the horizon and the segment aStartPoint to aEndPoint |
|||
* |
|||
* @param aStartPoint is the start point of a line segment |
|||
* @param aEndPoint is the end point of a line segment |
|||
* |
|||
* @return double: the angle in degrees |
|||
*/ |
|||
double CalcAngleDeg( const IDF_POINT& aStartPoint, const IDF_POINT& aEndPoint ); |
|||
|
|||
/** |
|||
* Function GetOutline |
|||
* takes contiguous elements from 'aLines' and stuffs them into 'aOutline'; elements put |
|||
* into the outline are deleted from aLines. This function is useful for sorting the jumbled |
|||
* mess of line segments and arcs which represent a board outline and cutouts in KiCad. |
|||
* The function will determine which segment element within aLines contains the leftmost |
|||
* point and retrieve the outline of which that segment is part. |
|||
* |
|||
* @param aLines (input/output) is a list of IDF segments which comprise an outline and |
|||
* cutouts. |
|||
* @param aOutline (output) is the ordered set of segments |
|||
*/ |
|||
void GetOutline( std::list<IDF_SEGMENT*>& aLines, |
|||
IDF_OUTLINE& aOutline ); |
|||
|
|||
#ifdef DEBUG_IDF |
|||
// prints out segment information for debug purposes |
|||
void PrintSeg( IDF_SEGMENT* aSegment ); |
|||
#endif |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Class IDF_NOTE |
|||
* represents an entry in the NOTE section of an IDF file |
|||
*/ |
|||
class IDF_NOTE |
|||
{ |
|||
private: |
|||
std::string text; // note text as per IDFv3 |
|||
double xpos; // text X position as per IDFv3 |
|||
double ypos; // text Y position as per IDFv3 |
|||
double height; // text height as per IDFv3 |
|||
double length; // text length as per IDFv3 |
|||
|
|||
public: |
|||
IDF_NOTE(); |
|||
|
|||
/** |
|||
* Function ReadNote |
|||
* reads a note entry from an IDFv3 file |
|||
* |
|||
* @param aBoardFile is an open BOARD file; the file position must be set to the start of a NOTE entry |
|||
* @param aBoardState is the parser's current state value |
|||
* @param aBoardUnit is the BOARD file's native units (MM or THOU) |
|||
* |
|||
* @return bool: true if a note item was read, false otherwise. In case of unrecoverable errors |
|||
* an exception is thrown |
|||
*/ |
|||
bool ReadNote( std::ifstream& aBoardFile, IDF3::FILE_STATE& aBoardState, IDF3::IDF_UNIT aBoardUnit ); |
|||
|
|||
/** |
|||
* Function WriteNote |
|||
* writes a note entry to an IDFv3 file |
|||
* |
|||
* @param aBoardFile is an open BOARD file; the file position must be within a NOTE section |
|||
* @param aBoardUnit is the BOARD file's native units (MM or THOU) |
|||
* |
|||
* @return bool: true if the item was successfully written, false otherwise. In case of |
|||
* unrecoverable errors an exception is thrown |
|||
*/ |
|||
bool WriteNote( std::ofstream& aBoardFile, IDF3::IDF_UNIT aBoardUnit ); |
|||
|
|||
/** |
|||
* Function SetText |
|||
* sets the text to be stored as a NOTE entry |
|||
*/ |
|||
void SetText( const std::string& aText ); |
|||
|
|||
/** |
|||
* Function SetPosition |
|||
* sets the position (mm) of the NOTE entry |
|||
*/ |
|||
void SetPosition( double aXpos, double aYpos ); |
|||
|
|||
/** |
|||
* Function SetSize |
|||
* sets the height and length (mm) of the NOTE entry |
|||
*/ |
|||
void SetSize( double aHeight, double aLength ); |
|||
|
|||
/** |
|||
* Function GetText |
|||
* returns the string stored in the note entry |
|||
*/ |
|||
const std::string& GetText( void ); |
|||
|
|||
/** |
|||
* Function GetText |
|||
* returns the position (mm) of the note entry |
|||
*/ |
|||
void GetPosition( double& aXpos, double& aYpos ); |
|||
|
|||
/** |
|||
* Function GetText |
|||
* returns the height and length (mm) of the note entry |
|||
*/ |
|||
void GetSize( double& aHeight, double& aLength ); |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* @Class IDF_DRILL_DATA |
|||
* contains information describing a drilled hole and is responsible for |
|||
* writing this information to a file in compliance with the IDFv3 specification. |
|||
*/ |
|||
class IDF_DRILL_DATA |
|||
{ |
|||
private: |
|||
double dia; |
|||
double x; |
|||
double y; |
|||
IDF3::KEY_PLATING plating; |
|||
IDF3::KEY_REFDES kref; |
|||
IDF3::KEY_HOLETYPE khole; |
|||
std::string refdes; |
|||
std::string holetype; |
|||
IDF3::KEY_OWNER owner; |
|||
|
|||
public: |
|||
/** |
|||
* Constructor IDF_DRILL_DATA |
|||
* creates an empty drill entry which can be populated by the |
|||
* Read() function |
|||
*/ |
|||
IDF_DRILL_DATA(); |
|||
|
|||
/** |
|||
* Constructor IDF_DRILL_DATA |
|||
* creates a drill entry with information compliant with the |
|||
* IDFv3 specifications. |
|||
* @param aDrillDia : drill diameter |
|||
* @param aPosX : X coordinate of the drill center |
|||
* @param aPosY : Y coordinate of the drill center |
|||
* @param aPlating : flag, PTH or NPTH |
|||
* @param aRefDes : component Reference Designator |
|||
* @param aHoleType : purpose of hole |
|||
* @param aOwner : one of MCAD, ECAD, UNOWNED |
|||
*/ |
|||
IDF_DRILL_DATA( double aDrillDia, double aPosX, double aPosY, |
|||
IDF3::KEY_PLATING aPlating, |
|||
const std::string aRefDes, |
|||
const std::string aHoleType, |
|||
IDF3::KEY_OWNER aOwner ); |
|||
|
|||
/** |
|||
* Function Matches |
|||
* returns true if the given drill diameter and location |
|||
* matches the diameter and location of this IDF_DRILL_DATA object |
|||
* |
|||
* @param aDrillDia is the drill diameter (mm) |
|||
* @param aPosX is the X position (mm) of the drilled hole |
|||
* @param aPosY is the Y position (mm) of the drilled hole |
|||
* |
|||
* @return bool: true if the diameter and position match this object |
|||
*/ |
|||
bool Matches( double aDrillDia, double aPosX, double aPosY ); |
|||
|
|||
/** |
|||
* Function Read |
|||
* read a drill entry from an IDFv3 file |
|||
* |
|||
* @param aBoardFile is an open IDFv3 file; the file position must be within the DRILLED_HOLES section |
|||
* @param aBoardUnit is the board file's native unit (MM or THOU) |
|||
* @param aBoardState is the state value of the parser |
|||
* |
|||
* @return bool: true if data was successfully read, otherwise false. In case of an |
|||
* unrecoverable error an exception is thrown |
|||
*/ |
|||
bool Read( std::ifstream& aBoardFile, IDF3::IDF_UNIT aBoardUnit, IDF3::FILE_STATE aBoardState ); |
|||
|
|||
/** |
|||
* Function Write |
|||
* writes a single line representing a hole within a .DRILLED_HOLES section |
|||
* |
|||
* @param aBoardFile is an open BOARD file |
|||
* @param aBoardUnit is the native unit of the output file |
|||
* |
|||
* @return bool: true if the data was successfully written, otherwise false. In case of |
|||
* an unrecoverable error an exception is thrown |
|||
*/ |
|||
bool Write( std::ofstream& aBoardFile, IDF3::IDF_UNIT aBoardUnit ); |
|||
|
|||
/** |
|||
* Function GettDrillDia |
|||
* returns the drill diameter in mm |
|||
*/ |
|||
double GetDrillDia(); |
|||
|
|||
|
|||
/** |
|||
* Function GettDrillXPos |
|||
* returns the drill's X position in mm |
|||
*/ |
|||
double GetDrillXPos(); |
|||
|
|||
/** |
|||
* Function GettDrillYPos |
|||
* returns the drill's Y position in mm |
|||
*/ |
|||
double GetDrillYPos(); |
|||
|
|||
/** |
|||
* Function GetDrillPlating |
|||
* returns the plating value (PTH, NPTH) |
|||
*/ |
|||
IDF3::KEY_PLATING GetDrillPlating(); |
|||
|
|||
/** |
|||
* Function GetDrillRefDes |
|||
* returns the reference designator of the hole; this |
|||
* may be a component reference designator, BOARD, or |
|||
* NOREFDES as per IDFv3. |
|||
*/ |
|||
const std::string& GetDrillRefDes(); |
|||
|
|||
/** |
|||
* Function GetDrillHoleType |
|||
* returns the classification of the hole; this may be one of |
|||
* PIN, VIA, MTG, TOOL, or a user-specified string |
|||
*/ |
|||
const std::string& GetDrillHoleType(); |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* @Class IDF_POINT |
|||
* represents a point as used by the various IDF related classes |
|||
*/ |
|||
class IDF_POINT |
|||
{ |
|||
public: |
|||
double x; // < X coordinate |
|||
double y; // < Y coordinate |
|||
|
|||
IDF_POINT() |
|||
{ |
|||
x = 0.0; |
|||
y = 0.0; |
|||
} |
|||
|
|||
/** |
|||
* Function Matches() |
|||
* returns true if the given coordinate point is within the given radius |
|||
* of the point. |
|||
* |
|||
* @param aPoint : coordinates of the point being compared |
|||
* @param aRadius : radius (mm) within which the points are considered the same |
|||
* |
|||
* @return bool: true if this point matches the given point |
|||
*/ |
|||
bool Matches( const IDF_POINT& aPoint, double aRadius = 1e-5 ); |
|||
|
|||
/** |
|||
* Function CalcDistance() |
|||
* returns the Euclidean distance between this point and the given point |
|||
* |
|||
* @param aPoint : coordinates of the point whose distance is to be determined |
|||
* |
|||
* @return double: distance between this point and aPoint |
|||
*/ |
|||
double CalcDistance( const IDF_POINT& aPoint ) const; |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* @Class IDF_SEGMENT |
|||
* represents a geometry segment as used in IDFv3 outlines; it may be any of |
|||
* an arc, line segment, or circle |
|||
*/ |
|||
class IDF_SEGMENT |
|||
{ |
|||
private: |
|||
/** |
|||
* Function CalcCenterAndRadius() |
|||
* Calculates the center, radius, and angle between center and start point given the |
|||
* IDF compliant points and included angle. |
|||
* |
|||
* @var startPoint, @var endPoint, and @var angle must be set prior as per IDFv3 |
|||
*/ |
|||
void CalcCenterAndRadius( void ); |
|||
|
|||
public: |
|||
IDF_POINT startPoint; ///< starting point coordinates in mm |
|||
IDF_POINT endPoint; ///< end point coordinates in mm |
|||
IDF_POINT center; ///< center of an arc or circle; internally calculated and not to be set by the user |
|||
double angle; ///< included angle (degrees) according to IDFv3 specification |
|||
double offsetAngle; ///< angle between center and start of arc; internally calculated |
|||
double radius; ///< radius of the arc or circle; internally calculated |
|||
|
|||
/** |
|||
* Constructor IDF_SEGMENT |
|||
* initializes the internal variables |
|||
*/ |
|||
IDF_SEGMENT(); |
|||
|
|||
/** |
|||
* Function IDF_SEGMENT |
|||
* creates a straight segment |
|||
*/ |
|||
IDF_SEGMENT( const IDF_POINT& aStartPoint, const IDF_POINT& aEndPoint ); |
|||
|
|||
/** |
|||
* Constructor IDF_SEGMENT |
|||
* creates a straight segment, arc, or circle depending on the angle |
|||
* |
|||
* @param aStartPoint : start point (center if using KiCad convention, otherwise IDF convention) |
|||
* @param aEndPoint : end point (start of arc if using KiCad convention, otherwise IDF convention) |
|||
* @param aAngle : included angle; the KiCad convention is equivalent to the IDF convention |
|||
* @param fromKicad : set true if we need to convert from KiCad to IDF convention |
|||
*/ |
|||
IDF_SEGMENT( const IDF_POINT& aStartPoint, |
|||
const IDF_POINT& aEndPoint, |
|||
double aAngle, |
|||
bool aFromKicad ); |
|||
|
|||
/** |
|||
* Function MatchesStart |
|||
* returns true if the given coordinate is within a radius 'rad' |
|||
* of the start point. |
|||
* |
|||
* @param aPoint : coordinates of the point (mm) being compared |
|||
* @param aRadius : radius (mm) within which the points are considered the same |
|||
* |
|||
* @return bool: true if the given point matches the start point of this segment |
|||
*/ |
|||
bool MatchesStart( const IDF_POINT& aPoint, double aRadius = 1e-3 ); |
|||
|
|||
/** |
|||
* Function MatchesEnd |
|||
* returns true if the given coordinate is within a radius 'rad' |
|||
* of the end point. |
|||
* |
|||
* @param aPoint : coordinates (mm) of the point being compared |
|||
* @param aRadius : radius (mm) within which the points are considered the same |
|||
* |
|||
* @return bool: true if the given point matches the end point of this segment |
|||
*/ |
|||
bool MatchesEnd( const IDF_POINT& aPoint, double aRadius = 1e-3 ); |
|||
|
|||
/** |
|||
* Function IsCircle |
|||
* returns true if this segment is a circle |
|||
*/ |
|||
bool IsCircle( void ); |
|||
|
|||
/** |
|||
* Function GetMinX() |
|||
* returns the minimum X coordinate of this segment |
|||
*/ |
|||
double GetMinX( void ); |
|||
|
|||
/** |
|||
* Function SwapEnds() |
|||
* Swaps the start and end points and alters internal |
|||
* variables as necessary for arcs |
|||
*/ |
|||
void SwapEnds( void ); |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* @Class IDF_OUTLINE |
|||
* contains segment and winding information for an IDF outline |
|||
*/ |
|||
class IDF_OUTLINE |
|||
{ |
|||
private: |
|||
double dir; // accumulator to help determine winding direction |
|||
std::list<IDF_SEGMENT*> outline; // sequential segments comprising an outline |
|||
|
|||
public: |
|||
IDF_OUTLINE() { dir = 0.0; } |
|||
~IDF_OUTLINE() { Clear(); } |
|||
|
|||
/** |
|||
* Function IsCCW |
|||
* returns true if the current list of points represents a counterclockwise winding |
|||
*/ |
|||
bool IsCCW( void ); |
|||
|
|||
/** |
|||
* Function IsCircle |
|||
* returns true if this outline is a circle |
|||
*/ |
|||
bool IsCircle( void ); |
|||
|
|||
/** |
|||
* Function Clear |
|||
* clears the internal list of outline segments |
|||
*/ |
|||
void Clear( void ) |
|||
{ |
|||
dir = 0.0; |
|||
|
|||
while( !outline.empty() ) |
|||
{ |
|||
delete outline.front(); |
|||
outline.pop_front(); |
|||
} |
|||
} |
|||
|
|||
/** |
|||
* Function size |
|||
* returns the size of the internal segment list |
|||
*/ |
|||
size_t size( void ) |
|||
{ |
|||
return outline.size(); |
|||
} |
|||
|
|||
/** |
|||
* Function empty |
|||
* returns true if the internal segment list is empty |
|||
*/ |
|||
bool empty( void ) |
|||
{ |
|||
return outline.empty(); |
|||
} |
|||
|
|||
/** |
|||
* Function front |
|||
* returns the front() iterator of the internal segment list |
|||
*/ |
|||
IDF_SEGMENT*& front( void ) |
|||
{ |
|||
return outline.front(); |
|||
} |
|||
|
|||
/** |
|||
* Function back |
|||
* returns the back() iterator of the internal segment list |
|||
*/ |
|||
IDF_SEGMENT*& back( void ) |
|||
{ |
|||
return outline.back(); |
|||
} |
|||
|
|||
/** |
|||
* Function begin |
|||
* returns the begin() iterator of the internal segment list |
|||
*/ |
|||
std::list<IDF_SEGMENT*>::iterator begin( void ) |
|||
{ |
|||
return outline.begin(); |
|||
} |
|||
|
|||
/** |
|||
* Function end |
|||
* returns the end() iterator of the internal segment list |
|||
*/ |
|||
std::list<IDF_SEGMENT*>::iterator end( void ) |
|||
{ |
|||
return outline.end(); |
|||
} |
|||
|
|||
/** |
|||
* Function push |
|||
* adds a segment to the internal segment list; segments must be added |
|||
* in order so that startPoint[N] == endPoint[N - 1] |
|||
* |
|||
* @param item is a pointer to the segment to add to the outline |
|||
* |
|||
* @return bool: true if the segment was added, otherwise false |
|||
* (outline restrictions have been violated) |
|||
*/ |
|||
bool push( IDF_SEGMENT* item ); |
|||
}; |
|||
|
|||
#endif // IDF_COMMON_H |
|||
@ -0,0 +1,149 @@ |
|||
.HEADER |
|||
BOARD_FILE 3.0 "Created by KiCad (2014-01-21 BZR 4629)-product" 2014/01/23.09:19:46 1 |
|||
"Arduino_MEGA_2560-Rev3.kicad_pcb" MM |
|||
.END_HEADER |
|||
|
|||
.BOARD_OUTLINE ECAD |
|||
1.60000 |
|||
0 246.20220 -25.67000 0 |
|||
0 247.20220 -26.67000 0 |
|||
0 344.26220 -26.67000 0 |
|||
0 345.26220 -25.67000 0 |
|||
0 345.26220 -25.40000 0 |
|||
0 347.80220 -22.86000 0 |
|||
0 347.80220 11.43000 0 |
|||
0 345.26220 13.97000 0 |
|||
0 345.26220 24.13000 0 |
|||
0 342.72220 26.67000 0 |
|||
0 247.20220 26.67000 0 |
|||
0 246.20220 25.67000 0 |
|||
0 246.20220 -25.67000 0 |
|||
.END_BOARD_OUTLINE |
|||
|
|||
.DRILLED_HOLES |
|||
3.200 342.72220 -24.13000 NPTH "@HOLE0" MTG ECAD |
|||
3.200 261.44220 24.13000 NPTH "@HOLE1" MTG ECAD |
|||
3.200 336.37220 24.13000 NPTH "@HOLE2" MTG ECAD |
|||
3.200 260.17220 -24.13000 NPTH "@HOLE3" MTG ECAD |
|||
3.200 312.24220 8.89000 NPTH "@HOLE4" MTG ECAD |
|||
3.200 312.24220 -19.05000 NPTH "@HOLE5" MTG ECAD |
|||
0.950 309.82920 3.81000 PTH "ICSP" PIN ECAD |
|||
0.950 312.36920 3.81000 PTH "ICSP" PIN ECAD |
|||
0.950 309.82920 1.27000 PTH "ICSP" PIN ECAD |
|||
0.950 312.36920 1.27000 PTH "ICSP" PIN ECAD |
|||
0.950 309.82920 -1.27000 PTH "ICSP" PIN ECAD |
|||
0.950 312.36920 -1.27000 PTH "ICSP" PIN ECAD |
|||
0.850 309.70220 24.13000 PTH "PWML" PIN ECAD |
|||
0.850 307.16220 24.13000 PTH "PWML" PIN ECAD |
|||
0.850 304.62220 24.13000 PTH "PWML" PIN ECAD |
|||
0.850 302.08220 24.13000 PTH "PWML" PIN ECAD |
|||
0.850 299.54220 24.13000 PTH "PWML" PIN ECAD |
|||
0.850 297.00220 24.13000 PTH "PWML" PIN ECAD |
|||
0.850 294.46220 24.13000 PTH "PWML" PIN ECAD |
|||
0.850 291.92220 24.13000 PTH "PWML" PIN ECAD |
|||
1.400 254.88900 -23.36800 PTH "X1" PIN ECAD |
|||
1.400 257.88620 -18.36420 PTH "X1" PIN ECAD |
|||
1.400 251.89180 -18.36420 PTH "X1" PIN ECAD |
|||
1.400 255.65100 -23.36800 PTH "X1" PIN ECAD |
|||
1.400 254.12700 -23.36800 PTH "X1" PIN ECAD |
|||
1.400 251.89180 -19.12620 PTH "X1" PIN ECAD |
|||
1.400 251.89180 -17.60220 PTH "X1" PIN ECAD |
|||
1.400 257.88620 -19.12620 PTH "X1" PIN ECAD |
|||
1.400 257.88620 -17.60220 PTH "X1" PIN ECAD |
|||
0.850 297.00220 -24.13000 PTH "ADCL" PIN ECAD |
|||
0.850 299.54220 -24.13000 PTH "ADCL" PIN ECAD |
|||
0.850 302.08220 -24.13000 PTH "ADCL" PIN ECAD |
|||
0.850 304.62220 -24.13000 PTH "ADCL" PIN ECAD |
|||
0.850 307.16220 -24.13000 PTH "ADCL" PIN ECAD |
|||
0.850 309.70220 -24.13000 PTH "ADCL" PIN ECAD |
|||
0.850 312.24220 -24.13000 PTH "ADCL" PIN ECAD |
|||
0.850 314.78220 -24.13000 PTH "ADCL" PIN ECAD |
|||
0.850 332.56220 24.13000 PTH "COMMUNICATION" PIN ECAD |
|||
0.850 330.02220 24.13000 PTH "COMMUNICATION" PIN ECAD |
|||
0.850 327.48220 24.13000 PTH "COMMUNICATION" PIN ECAD |
|||
0.850 324.94220 24.13000 PTH "COMMUNICATION" PIN ECAD |
|||
0.850 322.40220 24.13000 PTH "COMMUNICATION" PIN ECAD |
|||
0.850 319.86220 24.13000 PTH "COMMUNICATION" PIN ECAD |
|||
0.850 317.32220 24.13000 PTH "COMMUNICATION" PIN ECAD |
|||
0.850 314.78220 24.13000 PTH "COMMUNICATION" PIN ECAD |
|||
0.850 319.86220 -24.13000 PTH "ADCH" PIN ECAD |
|||
0.850 322.40220 -24.13000 PTH "ADCH" PIN ECAD |
|||
0.850 324.94220 -24.13000 PTH "ADCH" PIN ECAD |
|||
0.850 327.48220 -24.13000 PTH "ADCH" PIN ECAD |
|||
0.850 330.02220 -24.13000 PTH "ADCH" PIN ECAD |
|||
0.850 332.56220 -24.13000 PTH "ADCH" PIN ECAD |
|||
0.850 335.10220 -24.13000 PTH "ADCH" PIN ECAD |
|||
0.850 337.64220 -24.13000 PTH "ADCH" PIN ECAD |
|||
0.950 254.72220 10.18000 PTH "X2" PIN ECAD |
|||
0.950 254.72220 12.68000 PTH "X2" PIN ECAD |
|||
0.950 252.72220 12.68000 PTH "X2" PIN ECAD |
|||
0.950 252.72220 10.18000 PTH "X2" PIN ECAD |
|||
2.200 250.01220 17.43000 PTH "X2" PIN ECAD |
|||
2.200 250.01220 5.43000 PTH "X2" PIN ECAD |
|||
0.950 267.03020 20.82800 PTH "ICSP1" PIN ECAD |
|||
0.950 267.03020 18.28800 PTH "ICSP1" PIN ECAD |
|||
0.950 264.49020 20.82800 PTH "ICSP1" PIN ECAD |
|||
0.950 264.49020 18.28800 PTH "ICSP1" PIN ECAD |
|||
0.950 261.95020 20.82800 PTH "ICSP1" PIN ECAD |
|||
0.950 261.95020 18.28800 PTH "ICSP1" PIN ECAD |
|||
0.850 267.15720 -0.63500 PTH "Y2" PIN ECAD |
|||
0.850 262.07720 -0.63500 PTH "Y2" PIN ECAD |
|||
0.950 267.03020 13.20800 PTH "JP5" PIN ECAD |
|||
0.950 264.49020 13.20800 PTH "JP5" PIN ECAD |
|||
0.950 267.03020 15.74800 PTH "JP5" PIN ECAD |
|||
0.950 264.49020 15.74800 PTH "JP5" PIN ECAD |
|||
0.950 340.18220 24.13000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 24.13000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 21.59000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 21.59000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 19.05000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 19.05000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 16.51000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 16.51000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 13.97000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 13.97000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 11.43000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 11.43000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 8.89000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 8.89000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 6.35000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 6.35000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 3.81000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 3.81000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 1.27000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 1.27000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 -1.27000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 -1.27000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 -3.81000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 -3.81000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 -6.35000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 -6.35000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 -8.89000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 -8.89000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 -11.43000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 -11.43000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 -13.97000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 -13.97000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 -16.51000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 -16.51000 PTH "XIO" PIN ECAD |
|||
0.950 340.18220 -19.05000 PTH "XIO" PIN ECAD |
|||
0.950 342.72220 -19.05000 PTH "XIO" PIN ECAD |
|||
0.850 264.99820 24.13000 PTH "JP6" PIN ECAD |
|||
0.850 267.53820 24.13000 PTH "JP6" PIN ECAD |
|||
0.850 270.07820 24.13000 PTH "JP6" PIN ECAD |
|||
0.850 272.61820 24.13000 PTH "JP6" PIN ECAD |
|||
0.850 275.15820 24.13000 PTH "JP6" PIN ECAD |
|||
0.850 277.69820 24.13000 PTH "JP6" PIN ECAD |
|||
0.850 280.23820 24.13000 PTH "JP6" PIN ECAD |
|||
0.850 282.77820 24.13000 PTH "JP6" PIN ECAD |
|||
0.850 285.31820 24.13000 PTH "JP6" PIN ECAD |
|||
0.850 287.85820 24.13000 PTH "JP6" PIN ECAD |
|||
0.850 274.14220 -24.13000 PTH "POWER" PIN ECAD |
|||
0.850 276.68220 -24.13000 PTH "POWER" PIN ECAD |
|||
0.850 279.22220 -24.13000 PTH "POWER" PIN ECAD |
|||
0.850 281.76220 -24.13000 PTH "POWER" PIN ECAD |
|||
0.850 284.30220 -24.13000 PTH "POWER" PIN ECAD |
|||
0.850 286.84220 -24.13000 PTH "POWER" PIN ECAD |
|||
0.850 289.38220 -24.13000 PTH "POWER" PIN ECAD |
|||
0.850 291.92220 -24.13000 PTH "POWER" PIN ECAD |
|||
.END_DRILLED_HOLES |
|||
@ -0,0 +1,4 @@ |
|||
.HEADER |
|||
LIBRARY_FILE 3.0 "Created by KiCad (2014-01-21 BZR 4629)-product" 2014/01/23.09:19:46 1 |
|||
.END_HEADER |
|||
|
|||
@ -0,0 +1,269 @@ |
|||
.HEADER |
|||
BOARD_FILE 3.0 "Sample File Generator" 10/22/96.16:02:44 1 |
|||
sample_board THOU |
|||
.END_HEADER |
|||
|
|||
# This is the first BOARD section |
|||
# SEC1-0 |
|||
# SEC1-1 |
|||
.BOARD_OUTLINE MCAD |
|||
62.0 |
|||
0 5030.5 -120.0 0.0 |
|||
0 5187.5 -120.0 0.0 |
|||
0 5187.5 2130.0 0.0 |
|||
0 5155.0 2130.0 0.0 |
|||
0 5155.0 2550.0 -180.0 |
|||
0 5187.5 2550.0 0.0 |
|||
0 5187.5 4935.0 0.0 |
|||
0 4945.0 5145.0 0.0 |
|||
0 4945.0 5420.0 0.0 |
|||
0 4865.0 5500.0 0.0 |
|||
0 210.0 5500.0 0.0 |
|||
0 130.0 5420.0 0.0 |
|||
0 130.0 5145.0 0.0 |
|||
0 -112.5 4935.0 0.0 |
|||
0 -112.5 2550.0 0.0 |
|||
0 -80.0 2550.0 0.0 |
|||
0 -80.0 2130.0 -180.0 |
|||
0 -112.5 2130.0 0.0 |
|||
0 -112.5 -140.0 0.0 |
|||
0 45.5 -140.0 0.0 |
|||
0 45.5 -400.0 0.0 |
|||
0 2442.5 -400.0 0.0 |
|||
0 2442.5 -140.0 0.0 |
|||
0 2631.5 -140.0 0.0 |
|||
0 2631.5 -400.0 0.0 |
|||
0 5030.5 -400.0 0.0 |
|||
0 5030.5 -120.0 0.0 |
|||
1 2650.0 2350.0 0.0 |
|||
1 3000.0 2350.0 360.0 |
|||
.END_BOARD_OUTLINE |
|||
|
|||
|
|||
# This is the second BOARD section |
|||
# SEC2-0 |
|||
# SEC2-1 |
|||
# NOT SEC1-1 |
|||
.ROUTE_OUTLINE ECAD |
|||
ALL |
|||
0 5112.5 150.0 0.0 |
|||
0 5112.5 2058.2 0.0 |
|||
0 5112.5 2621.8 -162.9 |
|||
0 5112.5 4863.2 0.0 |
|||
0 4878.8 5075.0 0.0 |
|||
0 226.4 5075.0 0.0 |
|||
0 138.0 4910.3 0.0 |
|||
0 138.0 4800.0 0.0 |
|||
0 -37.5 4662.5 0.0 |
|||
0 -37.5 2621.8 0.0 |
|||
0 -37.5 2058.2 -162.9 |
|||
0 -37.5 150.0 0.0 |
|||
0 162.5 0.0 0.0 |
|||
0 4912.5 0.0 0.0 |
|||
0 5112.5 150.0 0.0 |
|||
.END_ROUTE_OUTLINE |
|||
|
|||
|
|||
# This is the third BOARD section |
|||
# SEC3-0 |
|||
# SEC3-1 |
|||
.PLACE_OUTLINE MCAD |
|||
TOP 1000.0 |
|||
0 5080.0 2034.9 0.0 |
|||
0 5080.0 2645.1 -152.9 |
|||
0 5080.0 4837.3 0.0 |
|||
0 4855.3 5042.5 0.0 |
|||
0 252.9 5042.5 0.0 |
|||
0 170.5 4896.9 0.0 |
|||
0 170.5 4798.4 0.0 |
|||
0 -5.0 4659.0 0.0 |
|||
0 -5.0 2645.1 0.0 |
|||
0 -5.0 2034.9 -152.9 |
|||
0 -5.0 182.5 0.0 |
|||
0 192.0 32.5 0.0 |
|||
0 4883.1 32.5 0.0 |
|||
0 5080.0 182.5 0.0 |
|||
0 5080.0 2034.9 0.0 |
|||
.END_PLACE_OUTLINE |
|||
|
|||
# This is the fourth BOARD section |
|||
# SEC4-0 |
|||
# SEC4-1 |
|||
.PLACE_OUTLINE UNOWNED |
|||
BOTTOM 200.0 |
|||
0 300.0 200.0 0.0 |
|||
0 4800.0 200.0 0.0 |
|||
0 4800.0 4800.0 0.0 |
|||
0 300.0 4800.0 0.0 |
|||
0 300.0 200.0 0.0 |
|||
.END_PLACE_OUTLINE |
|||
|
|||
|
|||
# This is the fifth BOARD section |
|||
# SEC5-0 |
|||
# SEC5-1 |
|||
.ROUTE_KEEPOUT ECAD |
|||
ALL |
|||
0 2650.0 2350.0 0.0 |
|||
0 3100.0 2350.0 360.0 |
|||
.END_ROUTE_KEEPOUT |
|||
|
|||
# This is the sixth BOARD section |
|||
# SEC6-0 |
|||
# SEC6-1 |
|||
.PLACE_KEEPOUT MCAD |
|||
BOTH 0.0 |
|||
0 2650.0 2350.0 0.0 |
|||
0 3100.0 2350.0 360.0 |
|||
.END_PLACE_KEEPOUT |
|||
|
|||
# This is the seventh BOARD section |
|||
# SEC7-0 |
|||
# SEC7-1 |
|||
.PLACE_KEEPOUT MCAD |
|||
TOP 300.0 |
|||
0 3700.0 5000.0 0.0 |
|||
0 3700.0 4300.0 0.0 |
|||
0 4000.0 4300.0 0.0 |
|||
0 4000.0 3700.0 0.0 |
|||
0 5000.0 3700.0 0.0 |
|||
0 5000.0 4800.0 0.0 |
|||
0 4800.0 5000.0 0.0 |
|||
0 3700.0 5000.0 0.0 |
|||
.END_PLACE_KEEPOUT |
|||
|
|||
|
|||
# This is the eighth BOARD section |
|||
# SEC8-0 |
|||
# SEC8-1 |
|||
.DRILLED_HOLES |
|||
30.0 1800.0 100.0 PTH J1 PIN ECAD |
|||
30.0 1700.0 100.0 PTH J1 PIN ECAD |
|||
30.0 1600.0 100.0 PTH J1 PIN ECAD |
|||
30.0 1500.0 100.0 PTH J1 PIN ECAD |
|||
30.0 1400.0 100.0 PTH J1 PIN ECAD |
|||
30.0 1300.0 100.0 PTH J1 PIN ECAD |
|||
30.0 1200.0 100.0 PTH J1 PIN ECAD |
|||
30.0 1100.0 100.0 PTH J1 PIN ECAD |
|||
30.0 1000.0 100.0 PTH J1 PIN ECAD |
|||
30.0 0900.0 100.0 PTH J1 PIN ECAD |
|||
30.0 0800.0 100.0 PTH J1 PIN ECAD |
|||
30.0 0700.0 100.0 PTH J1 PIN ECAD |
|||
30.0 0700.0 200.0 PTH J1 PIN ECAD |
|||
30.0 0800.0 200.0 PTH J1 PIN ECAD |
|||
30.0 0900.0 200.0 PTH J1 PIN ECAD |
|||
30.0 1000.0 200.0 PTH J1 PIN ECAD |
|||
30.0 1100.0 200.0 PTH J1 PIN ECAD |
|||
30.0 1200.0 200.0 PTH J1 PIN ECAD |
|||
30.0 1300.0 200.0 PTH J1 PIN ECAD |
|||
30.0 1400.0 200.0 PTH J1 PIN ECAD |
|||
30.0 1500.0 200.0 PTH J1 PIN ECAD |
|||
30 1600 200 PTH J1 PIN ECAD |
|||
30 1700 200 PTH J1 PIN ECAD |
|||
30 1800 200 PTH J1 PIN ECAD |
|||
30 4400 100 PTH J2 PIN ECAD |
|||
30 4300 100 PTH J2 PIN ECAD |
|||
30 4200 100 PTH J2 PIN ECAD |
|||
30 4100 100 PTH J2 PIN ECAD |
|||
30 4000 100 PTH J2 PIN ECAD |
|||
30 3900 100 PTH J2 PIN ECAD |
|||
30 3800 100 PTH J2 PIN ECAD |
|||
30 3700 100 PTH J2 PIN ECAD |
|||
30 3600 100 PTH J2 PIN ECAD |
|||
30 3500 100 PTH J2 PIN ECAD |
|||
30 3400 100 PTH J2 PIN ECAD |
|||
30 3300 100 PTH J2 PIN ECAD |
|||
30 3300 200 PTH J2 PIN ECAD |
|||
30 3400 200 PTH J2 PIN ECAD |
|||
30 3500 200 PTH J2 PIN ECAD |
|||
30 3600 200 PTH J2 PIN ECAD |
|||
30 3700 200 PTH J2 PIN ECAD |
|||
30 3800 200 PTH J2 PIN ECAD |
|||
30 3900 200 PTH J2 PIN ECAD |
|||
30 4000 200 PTH J2 PIN ECAD |
|||
30 4100 200 PTH J2 PIN ECAD |
|||
30 4200 200 PTH J2 PIN ECAD |
|||
30 4300 200 PTH J2 PIN ECAD |
|||
30 4400 200 PTH J2 PIN ECAD |
|||
30 3000 3300 PTH U3 PIN ECAD |
|||
30 3024.2 3203 PTH U3 PIN ECAD |
|||
30 3048.4 3105.9 PTH U3 PIN ECAD |
|||
30 3072.6 3008.9 PTH U3 PIN ECAD |
|||
30 3096.8 2911.9 PTH U3 PIN ECAD |
|||
30 3121 2814.9 PTH U3 PIN ECAD |
|||
30 3145.2 2717.8 PTH U3 PIN ECAD |
|||
30 3436.2 2790.4 PTH U3 PIN ECAD |
|||
30 3412.1 2887.4 PTH U3 PIN ECAD |
|||
30 3387.9 2984.5 PTH U3 PIN ECAD |
|||
30 3363.7 3081.5 PTH U3 PIN ECAD |
|||
30 3339.5 3178.5 PTH U3 PIN ECAD |
|||
30 3315.3 3275.6 PTH U3 PIN ECAD |
|||
30 3291.1 3372.6 PTH U3 PIN ECAD |
|||
30 2200 2500 PTH U4 PIN ECAD |
|||
30 2100 2500 PTH U4 PIN ECAD |
|||
30 2000 2500 PTH U4 PIN ECAD |
|||
30 1900 2500 PTH U4 PIN ECAD |
|||
30 1800 2500 PTH U4 PIN ECAD |
|||
30 1700 2500 PTH U4 PIN ECAD |
|||
30 1600 2500 PTH U4 PIN ECAD |
|||
30 1600 2200 PTH U4 PIN ECAD |
|||
30 1700 2200 PTH U4 PIN ECAD |
|||
30 1800 2200 PTH U4 PIN ECAD |
|||
30 1900 2200 PTH U4 PIN ECAD |
|||
30 2000 2200 PTH U4 PIN ECAD |
|||
30 2100 2200 PTH U4 PIN ECAD |
|||
30 2200 2200 PTH U4 PIN ECAD |
|||
20 2500 3100 PTH BOARD VIA ECAD |
|||
20 2500 3200 PTH BOARD VIA ECAD |
|||
20 2500 3300 PTH BOARD VIA ECAD |
|||
20 2000 1600 PTH BOARD VIA ECAD |
|||
20 1100 900 PTH BOARD VIA ECAD |
|||
20 1200 1600 PTH BOARD VIA ECAD |
|||
20 3900 3800 PTH BOARD VIA ECAD |
|||
20 3900 2300 PTH BOARD VIA ECAD |
|||
100.0 3100.0 -50.0 NPTH J2 MTG ECAD |
|||
100.0 4600.0 -50.0 NPTH J2 MTG ECAD |
|||
100.0 500.0 -50.0 NPTH J1 MTG ECAD |
|||
100.0 2000.0 -50.0 NPTH J1 MTG ECAD |
|||
93.0 5075.0 0.0 PTH BOARD MTG UNOWNED |
|||
93.0 0.0 4800.0 NPTH BOARD TOOL MCAD |
|||
93.0 0.0 0.0 PTH BOARD MTG UNOWNED |
|||
.END_DRILLED_HOLES |
|||
|
|||
|
|||
# This is the ninth BOARD section |
|||
# SEC9-0 |
|||
# SEC9-1 |
|||
.NOTES |
|||
3500.0 3300.0 75.0 2500.0 "This component rotated 14 degrees" |
|||
400.0 4400.0 75.0 3200.0 "Component height limited by enclosure latch" |
|||
1800.0 300.0 75.0 1700.0 "Do not move connectors!" |
|||
.END_NOTES |
|||
|
|||
# This is the tenth and ALWAYS FINAL BOARD section |
|||
# SEC10-0 |
|||
# SEC10-1 |
|||
.PLACEMENT |
|||
cs13_a pn-cap C1 |
|||
4000.0 1000.0 100.0 0.0 TOP PLACED |
|||
cc1210 pn-cc1210 C2 |
|||
3000.0 3500.0 0.0 0.0 TOP PLACED |
|||
cc1210 pn-cc1210 C3 |
|||
3200.0 1800.0 0.0 0.0 BOTTOM PLACED |
|||
cc1210 pn-cc1210 C4 |
|||
1400.0 2300.0 0.0 270.0 TOP PLACED |
|||
cc1210 pn-cc1210 C5 |
|||
1799.5 3518.1 0.0 0.0 BOTTOM PLACED |
|||
conn_din24 connector J1 |
|||
1800.0 100.0 0.0 0.0 TOP MCAD |
|||
conn_din24 connector J2 |
|||
4400.0 100.0 0.0 0.0 TOP MCAD |
|||
plcc_20 pn-pal16l8-plcc U1 |
|||
1800.0 3200.0 0.0 0.0 BOTTOM ECAD |
|||
plcc_20 pn-pal16l8-plcc U2 |
|||
3200.0 1800.0 0.0 0.0 TOP PLACED |
|||
dip_14w pn-hs346-dip U3 |
|||
3000.0 3300.0 0.0 14.0 TOP PLACED |
|||
dip_14w pn-hs346-dip U4 |
|||
2200.0 2500.0 0.0 270.0 TOP PLACED |
|||
.END_PLACEMENT |
|||
@ -0,0 +1,69 @@ |
|||
.HEADER |
|||
LIBRARY_file 3.0 "Sample File Generator" 10/22/96.16:41:37 1 |
|||
.END_HEADER |
|||
|
|||
# Component #1/5 |
|||
.ELECTRICAL |
|||
cs13_a pn-cap THOU 150.0 |
|||
0 -55.0 55.0 0.0 |
|||
0 -55.0 -55.0 0.0 |
|||
0 135.0 -55.0 0.0 |
|||
0 135.0 -80.0 0.0 |
|||
0 565.0 -80.0 0.0 |
|||
0 565.0 -55.0 0.0 |
|||
0 755.0 -55.0 0.0 |
|||
0 755.0 55.0 0.0 |
|||
0 565.0 55.0 0.0 |
|||
0 565.0 80.0 0.0 |
|||
0 135.0 80.0 0.0 |
|||
0 135.0 55.0 0.0 |
|||
0 -55.0 55.0 0.0 |
|||
PROP CAPACITANCE 100.0 |
|||
PROP TOLERANCE 5.0 |
|||
.END_ELECTRICAL |
|||
|
|||
|
|||
# Component #2/5 |
|||
.ELECTRICAL |
|||
cc1210 pn-cc1210 THOU 67.0 |
|||
0 -40.0 56.0 0.0 |
|||
0 -40.0 -56.0 0.0 |
|||
0 182.0 -56.0 0.0 |
|||
0 182.0 56.0 0.0 |
|||
0 -40.0 56.0 0.0 |
|||
PROP CAPACITANCE 0.1 |
|||
PROP TOLERANCE 5.0 |
|||
.END_ELECTRICAL |
|||
|
|||
# Component #3/5 |
|||
.ELECTRICAL |
|||
conn_din24 connector THOU 435.0 |
|||
0 -1400.0 -500.0 0.0 |
|||
0 300.0 -500.0 0.0 |
|||
0 300.0 150.0 0.0 |
|||
0 -1400.0 150.0 0.0 |
|||
0 -1400.0 -500.0 0.0 |
|||
.END_ELECTRICAL |
|||
|
|||
|
|||
# Component #4/5 |
|||
.ELECTRICAL |
|||
dip_14w pn-hs346-dip THOU 200.0 |
|||
0 350.0 50.0 0.0 |
|||
0 -50.0 50.0 0.0 |
|||
0 -50.0 -650.0 0.0 |
|||
0 350.0 -650.0 0.0 |
|||
0 350.0 50.0 0.0 |
|||
.END_ELECTRICAL |
|||
|
|||
|
|||
# Component #5/5 |
|||
.ELECTRICAL |
|||
plcc_20 pn-pal16l8-plcc THOU 14.0 |
|||
0 -200.0 240.0 0.0 |
|||
0 -240.0 200.0 0.0 |
|||
0 -240.0 -240.0 0.0 |
|||
0 240.0 -240.0 0.0 |
|||
0 240.0 240.0 0.0 |
|||
0 -200.0 240.0 0.0 |
|||
.END_ELECTRICAL |
|||
@ -0,0 +1,71 @@ |
|||
.HEADER |
|||
BOARD_FILE 3.0 "Created by KiCad (2014-01-25 BZR 4633)-product" 2014/02/01.15:09:15 1 |
|||
"test_idf2.kicad_pcb" MM |
|||
.END_HEADER |
|||
|
|||
.BOARD_OUTLINE ECAD |
|||
1.60000 |
|||
0 -86.00000 42.00000 0 |
|||
0 -86.00000 -42.00000 0 |
|||
0 86.00000 -42.00000 0 |
|||
0 86.00000 42.00000 0 |
|||
0 -86.00000 42.00000 0 |
|||
.END_BOARD_OUTLINE |
|||
|
|||
.DRILLED_HOLES |
|||
0.800 -74.00000 16.00000 PTH BOARD PIN ECAD |
|||
0.800 -74.00000 -28.00000 PTH BOARD PIN ECAD |
|||
0.850 -55.75000 16.00000 PTH BOARD PIN ECAD |
|||
0.850 -52.25000 16.00000 PTH BOARD PIN ECAD |
|||
0.850 -35.75000 16.00000 PTH BOARD PIN ECAD |
|||
0.850 -32.25000 16.00000 PTH BOARD PIN ECAD |
|||
1.575 -57.17500 -28.00000 PTH BOARD PIN ECAD |
|||
1.575 -50.82500 -28.00000 PTH BOARD PIN ECAD |
|||
1.575 -37.17500 -28.00000 PTH BOARD PIN ECAD |
|||
1.575 -30.82500 -28.00000 PTH BOARD PIN ECAD |
|||
0.800 -14.00000 16.00000 PTH BOARD PIN ECAD |
|||
0.800 -14.00000 -28.00000 PTH BOARD PIN ECAD |
|||
0.800 6.00000 16.00000 PTH BOARD PIN ECAD |
|||
0.800 6.00000 -28.00000 PTH BOARD PIN ECAD |
|||
0.800 26.00000 16.00000 PTH BOARD PIN ECAD |
|||
0.800 26.00000 -28.00000 PTH BOARD PIN ECAD |
|||
0.800 46.00000 16.00000 PTH BOARD PIN ECAD |
|||
0.800 46.00000 -28.00000 PTH BOARD PIN ECAD |
|||
0.800 66.00000 16.00000 PTH BOARD PIN ECAD |
|||
0.800 66.00000 -28.00000 PTH BOARD PIN ECAD |
|||
.END_DRILLED_HOLES |
|||
|
|||
.PLACEMENT |
|||
"CYLV_MM" "D5.000_H8.000_Z3.000" "NOREFDES_0" |
|||
-74.000000 16.000000 0.000000 0.000 TOP ECAD |
|||
"CYLV_IN" "D0.250_H0.250_Z0.127" "NOREFDES_1" |
|||
-74.000000 -28.000000 0.000000 0.000 TOP ECAD |
|||
"CYLV_MM_L" "D5.000_H8.000_Z3.000_WD0.800_P3.500" "NOREFDES_2" |
|||
-54.000000 16.000000 0.000000 0.000 TOP ECAD |
|||
"CYLV_MM_R" "D5.000_H8.000_Z3.000_WD0.800_P3.500" "NOREFDES_3" |
|||
-34.000000 16.000000 0.000000 0.000 TOP ECAD |
|||
"CYLV_IN_L" "D0.250_H0.250_Z0.127_WD0.062_P0.250" "NOREFDES_4" |
|||
-54.000000 -28.000000 0.000000 0.000 TOP ECAD |
|||
"CYLV_IN_R" "D0.250_H0.250_Z0.127_WD0.062_P0.250" "NOREFDES_5" |
|||
-34.000000 -28.000000 0.000000 0.000 TOP ECAD |
|||
"CYLH_MM_AXI" "D2.500_H4.000_Z0.500_WD0.600_P8.000" "NOREFDES_6" |
|||
-14.000000 16.000000 0.000000 0.000 TOP ECAD |
|||
"CYLH_IN_AXI" "D0.098_H0.157_Z0.020_WD0.024_P0.315" "NOREFDES_7" |
|||
-14.000000 -28.000000 0.000000 0.000 TOP ECAD |
|||
"CYLH_MM_RAD" "D5.000_H6.000_Z0.200_WD0.600_P2.500_L3.000" "NOREFDES_8" |
|||
6.000000 16.000000 0.000000 0.000 TOP ECAD |
|||
"CYLH_IN_RAD" "D0.197_H0.236_Z0.008_WD0.024_P0.098_L0.118" "NOREFDES_9" |
|||
6.000000 -28.000000 0.000000 0.000 TOP ECAD |
|||
"RECTMM" "W10.000_L10.000_H6.000_C0.000" "NOREFDES_10" |
|||
26.000000 16.000000 0.000000 0.000 TOP ECAD |
|||
"RECTIN" "W393_L393_H236_C0" "NOREFDES_11" |
|||
26.000000 -28.000000 0.000000 0.000 TOP ECAD |
|||
"RECTMM" "W10.000_L10.000_H2.000_C0.500" "NOREFDES_12" |
|||
46.000000 16.000000 0.000000 0.000 TOP ECAD |
|||
"RECTIN" "W393_L393_H78_C19" "NOREFDES_13" |
|||
46.000000 -28.000000 0.000000 0.000 TOP ECAD |
|||
"RECTLMM" "W10.000_L10.000_H12.000_D0.800_P6.000" "NOREFDES_14" |
|||
66.000000 16.000000 0.000000 0.000 TOP ECAD |
|||
"RECTLIN" "W393_L393_H472_D31_P236" "NOREFDES_15" |
|||
66.000000 -28.000000 0.000000 0.000 TOP ECAD |
|||
.END_PLACEMENT |
|||
@ -0,0 +1,290 @@ |
|||
.HEADER |
|||
LIBRARY_FILE 3.0 "Created by KiCad (2014-01-25 BZR 4633)-product" 2014/02/01.15:09:15 1 |
|||
.END_HEADER |
|||
|
|||
# cylindrical outline, vertical, no pins |
|||
# file: "cylvmm_0_D5_L8_Z3.idf" |
|||
# dia: 5.000 mm |
|||
# length: 8.000 mm |
|||
# extra height: 3.000 mm |
|||
.ELECTRICAL |
|||
"CYLV_MM" "D5.000_H8.000_Z3.000" MM 11.000 |
|||
0 0 0 0 |
|||
0 5.000 0 360 |
|||
.END_ELECTRICAL |
|||
|
|||
# cylindrical outline, vertical, no pins |
|||
# file: "cylvin_0_D0.25_L0.25_Z0.127.idf" |
|||
# dia: 250 THOU |
|||
# length: 250 THOU |
|||
# extra height: 127 THOU |
|||
.ELECTRICAL |
|||
"CYLV_IN" "D0.250_H0.250_Z0.127" THOU 377 |
|||
0 0 0 0 |
|||
0 250 0 360 |
|||
.END_ELECTRICAL |
|||
|
|||
# cylindrical outline, vertical, 1 pin on left |
|||
# file: "cylvmm_1L_D5_L8_Z3_WD0.8_P3.5.idf" |
|||
# dia: 5.000 mm |
|||
# length: 8.000 mm |
|||
# extra height: 3.000 mm |
|||
# wire dia: 0.800 mm |
|||
# pitch: 3.500 mm |
|||
.ELECTRICAL |
|||
"CYLV_MM_L" "D5.000_H8.000_Z3.000_WD0.800_P3.500" MM 11.000 |
|||
1 -0.718 0.400 0 |
|||
1 -0.718 -0.400 -341.586 |
|||
1 -1.750 -0.400 0 |
|||
1 -1.750 0.400 -180 |
|||
1 -0.718 0.400 0 |
|||
.END_ELECTRICAL |
|||
|
|||
# cylindrical outline, vertical, 1 pin on right |
|||
# file: "cylvmm_1R_D5_L8_Z3_WD0.8_P3.5.idf" |
|||
# dia: 5.000 mm |
|||
# length: 8.000 mm |
|||
# extra height: 3.000 mm |
|||
# wire dia: 0.800 mm |
|||
# pitch: 3.500 mm |
|||
.ELECTRICAL |
|||
"CYLV_MM_R" "D5.000_H8.000_Z3.000_WD0.800_P3.500" MM 11.000 |
|||
0 0.718 0.400 0 |
|||
0 0.718 -0.400 341.586 |
|||
0 1.750 -0.400 0 |
|||
0 1.750 0.400 180 |
|||
0 0.718 0.400 0 |
|||
.END_ELECTRICAL |
|||
|
|||
# cylindrical outline, vertical, 1 pin on left |
|||
# file: "cylvin_1L_D0.25_L0.25_Z0.127_WD0.062_P0.25.idf" |
|||
# dia: 250 THOU |
|||
# length: 250 THOU |
|||
# extra height: 127 THOU |
|||
# wire dia: 62 THOU |
|||
# pitch: 250 THOU |
|||
.ELECTRICAL |
|||
"CYLV_IN_L" "D0.250_H0.250_Z0.127_WD0.062_P0.250" THOU 377 |
|||
1 3 31 0 |
|||
1 3 -31 -331.282 |
|||
1 -125 -31 0 |
|||
1 -125 31 -180 |
|||
1 3 31 0 |
|||
.END_ELECTRICAL |
|||
|
|||
# cylindrical outline, vertical, 1 pin on right |
|||
# file: "cylvin_1R_D0.25_L0.25_Z0.127_WD0.062_P0.25.idf" |
|||
# dia: 250 THOU |
|||
# length: 250 THOU |
|||
# extra height: 127 THOU |
|||
# wire dia: 62 THOU |
|||
# pitch: 250 THOU |
|||
.ELECTRICAL |
|||
"CYLV_IN_R" "D0.250_H0.250_Z0.127_WD0.062_P0.250" THOU 377 |
|||
0 -3 31 0 |
|||
0 -3 -31 331.282 |
|||
0 125 -31 0 |
|||
0 125 31 180 |
|||
0 -3 31 0 |
|||
.END_ELECTRICAL |
|||
|
|||
# cylindrical outline, horiz., axial pins |
|||
# file: "resistor.idf" |
|||
# dia: 2.500 mm |
|||
# length: 4.000 mm |
|||
# extra height: 0.500 mm |
|||
# wire dia: 0.600 mm |
|||
# pitch: 8.000 mm |
|||
.ELECTRICAL |
|||
"CYLH_MM_AXI" "D2.500_H4.000_Z0.500_WD0.600_P8.000" MM 3.000 |
|||
0 -2.000 1.250 0 |
|||
0 -2.000 0.300 0 |
|||
0 -4.000 0.300 0 |
|||
0 -4.000 -0.300 180 |
|||
0 -2.000 -0.300 0 |
|||
0 -2.000 -1.250 0 |
|||
0 2.000 -1.250 0 |
|||
0 2.000 -0.300 0 |
|||
0 4.000 -0.300 0 |
|||
0 4.000 0.300 180 |
|||
0 2.000 0.300 0 |
|||
0 2.000 1.250 0 |
|||
0 -2.000 1.250 0 |
|||
.END_ELECTRICAL |
|||
|
|||
# cylindrical outline, horiz., axial pins |
|||
# file: "resistor_in.idf" |
|||
# dia: 98 THOU |
|||
# length: 157 THOU |
|||
# extra height: 20 THOU |
|||
# wire dia: 24 THOU |
|||
# pitch: 315 THOU |
|||
.ELECTRICAL |
|||
"CYLH_IN_AXI" "D0.098_H0.157_Z0.020_WD0.024_P0.315" THOU 118 |
|||
0 -78 49 0 |
|||
0 -78 12 0 |
|||
0 -157 12 0 |
|||
0 -157 -12 180 |
|||
0 -78 -12 0 |
|||
0 -78 -49 0 |
|||
0 78 -49 0 |
|||
0 78 -12 0 |
|||
0 157 -12 0 |
|||
0 157 12 180 |
|||
0 78 12 0 |
|||
0 78 49 0 |
|||
0 -78 49 0 |
|||
.END_ELECTRICAL |
|||
|
|||
# cylindrical outline, horiz., radial pins |
|||
# file: "capacitor.idf" |
|||
# dia: 5.000 mm |
|||
# length: 6.000 mm |
|||
# extra height: 0.200 mm |
|||
# wire dia: 0.600 mm |
|||
# pitch: 2.500 mm |
|||
# lead: 3.000 mm |
|||
.ELECTRICAL |
|||
"CYLH_MM_RAD" "D5.000_H6.000_Z0.200_WD0.600_P2.500_L3.000" MM 5.200 |
|||
0 -2.500 9.000 0 |
|||
0 -2.500 3.000 0 |
|||
0 -1.550 3.000 0 |
|||
0 -1.550 0 0 |
|||
0 -0.950 0 180 |
|||
0 -0.950 3.000 0 |
|||
0 0.950 3.000 0 |
|||
0 0.950 0 0 |
|||
0 1.550 0 180 |
|||
0 1.550 3.000 0 |
|||
0 2.500 3.000 0 |
|||
0 2.500 9.000 0 |
|||
0 -2.500 9.000 0 |
|||
.END_ELECTRICAL |
|||
|
|||
# cylindrical outline, horiz., radial pins |
|||
# file: "capacitor_in.idf" |
|||
# dia: 197 THOU |
|||
# length: 236 THOU |
|||
# extra height: 8 THOU |
|||
# wire dia: 24 THOU |
|||
# pitch: 98 THOU |
|||
# lead: 118 THOU |
|||
.ELECTRICAL |
|||
"CYLH_IN_RAD" "D0.197_H0.236_Z0.008_WD0.024_P0.098_L0.118" THOU 205 |
|||
0 -98 354 0 |
|||
0 -98 118 0 |
|||
0 -61 118 0 |
|||
0 -61 0 0 |
|||
0 -37 0 180 |
|||
0 -37 118 0 |
|||
0 37 118 0 |
|||
0 37 0 0 |
|||
0 61 0 180 |
|||
0 61 118 0 |
|||
0 98 118 0 |
|||
0 98 354 0 |
|||
0 -98 354 0 |
|||
.END_ELECTRICAL |
|||
|
|||
# rectangular outline |
|||
# file: "rectMM_10x10x6_C0.idf" |
|||
# width: 10.000 mm |
|||
# length: 10.000 mm |
|||
# height: 6.000 mm |
|||
# chamfer: 0.000 mm |
|||
.ELECTRICAL |
|||
"RECTMM" "W10.000_L10.000_H6.000_C0.000" MM 6.000 |
|||
0 5.000 5.000 0 |
|||
0 -5.000 5.000 0 |
|||
0 -5.000 -5.000 0 |
|||
0 5.000 -5.000 0 |
|||
0 5.000 5.000 0 |
|||
.END_ELECTRICAL |
|||
|
|||
# rectangular outline |
|||
# file: "rectIN_10x10x6mm_C0mm.idf" |
|||
# width: 393 THOU |
|||
# length: 393 THOU |
|||
# height: 236 THOU |
|||
# chamfer: 0 THOU |
|||
.ELECTRICAL |
|||
"RECTIN" "W393_L393_H236_C0" THOU 236 |
|||
0 196 196 0 |
|||
0 -196 196 0 |
|||
0 -196 -196 0 |
|||
0 196 -196 0 |
|||
0 196 196 0 |
|||
.END_ELECTRICAL |
|||
|
|||
# rectangular outline |
|||
# file: "rectMM_10x10x2_C0.5.idf" |
|||
# width: 10.000 mm |
|||
# length: 10.000 mm |
|||
# height: 2.000 mm |
|||
# chamfer: 0.500 mm |
|||
.ELECTRICAL |
|||
"RECTMM" "W10.000_L10.000_H2.000_C0.500" MM 2.000 |
|||
0 5.000 5.000 0 |
|||
0 -4.500 5.000 0 |
|||
0 -5.000 4.500 0 |
|||
0 -5.000 -5.000 0 |
|||
0 5.000 -5.000 0 |
|||
0 5.000 5.000 0 |
|||
.END_ELECTRICAL |
|||
|
|||
# rectangular outline |
|||
# file: "rectIN_10x10x2mm_C0.5mm.idf" |
|||
# width: 393 THOU |
|||
# length: 393 THOU |
|||
# height: 78 THOU |
|||
# chamfer: 19 THOU |
|||
.ELECTRICAL |
|||
"RECTIN" "W393_L393_H78_C19" THOU 78 |
|||
0 196 196 0 |
|||
0 -176 196 0 |
|||
0 -196 176 0 |
|||
0 -196 -196 0 |
|||
0 196 -196 0 |
|||
0 196 196 0 |
|||
.END_ELECTRICAL |
|||
|
|||
# rectangular outline, leaded |
|||
# file: "rectLMM_10x10x12_D0.8_P6.0.idf" |
|||
# width: 10.000 mm |
|||
# length: 10.000 mm |
|||
# height: 12.000 mm |
|||
# wire dia: 0.800 mm |
|||
# pitch: 6.000 mm |
|||
.ELECTRICAL |
|||
"RECTLMM" "W10.000_L10.000_H12.000_D0.800_P6.000" MM 12.000 |
|||
0 3.000 0.400 0 |
|||
0 2.000 0.400 0 |
|||
0 2.000 5.000 0 |
|||
0 -8.000 5.000 0 |
|||
0 -8.000 -5.000 0 |
|||
0 2.000 -5.000 0 |
|||
0 2.000 -0.400 0 |
|||
0 3.000 -0.400 0 |
|||
0 3.000 0.400 180 |
|||
.END_ELECTRICAL |
|||
|
|||
# rectangular outline, leaded |
|||
# file: "rectLIN_10x10x12mm_D0.8mm_P6.0mm.idf" |
|||
# width: 393 THOU |
|||
# length: 393 THOU |
|||
# height: 472 THOU |
|||
# wire dia: 31 THOU |
|||
# pitch: 236 THOU |
|||
.ELECTRICAL |
|||
"RECTLIN" "W393_L393_H472_D31_P236" THOU 472 |
|||
0 118 15 0 |
|||
0 78 15 0 |
|||
0 78 196 0 |
|||
0 -315 196 0 |
|||
0 -315 -196 0 |
|||
0 78 -196 0 |
|||
0 78 -15 0 |
|||
0 118 -15 0 |
|||
0 118 15 180 |
|||
.END_ELECTRICAL |
|||
|
|||
@ -0,0 +1,295 @@ |
|||
/*
|
|||
* This program source code file is part of KiCad, a free EDA CAD application. |
|||
* |
|||
* Copyright (C) 2014 Cirilo Bernardo |
|||
* |
|||
* This program is free software; you can redistribute it and/or |
|||
* modify it under the terms of the GNU General Public License |
|||
* as published by the Free Software Foundation; either version 2 |
|||
* of the License, or (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program; if not, you may find one here: |
|||
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|||
* or you may search the http://www.gnu.org website for the version 2 license,
|
|||
* or you may write to the Free Software Foundation, Inc., |
|||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA |
|||
*/ |
|||
|
|||
#include <cctype>
|
|||
#include <iostream>
|
|||
#include <sstream>
|
|||
|
|||
#include <idf_common.h>
|
|||
#include <idf_helpers.h>
|
|||
|
|||
using namespace std; |
|||
using namespace IDF3; |
|||
|
|||
// fetch a line from the given input file and trim the ends
|
|||
bool IDF3::FetchIDFLine( std::ifstream& aModel, std::string& aLine, bool& isComment, std::streampos& aFilePos ) |
|||
{ |
|||
aLine = ""; |
|||
aFilePos = aModel.tellg(); |
|||
|
|||
if( aFilePos == -1 ) |
|||
return false; |
|||
|
|||
std::getline( aModel, aLine ); |
|||
|
|||
isComment = false; |
|||
|
|||
// A comment begins with a '#' and must be the first character on the line
|
|||
if( aLine[0] == '#' ) |
|||
{ |
|||
// opening '#' is stripped
|
|||
isComment = true; |
|||
aLine.erase( aLine.begin() ); |
|||
} |
|||
|
|||
// strip leading and trailing spaces
|
|||
while( !aLine.empty() && isspace( *aLine.begin() ) ) |
|||
aLine.erase( aLine.begin() ); |
|||
|
|||
while( !aLine.empty() && isspace( *aLine.rbegin() ) ) |
|||
aLine.erase( --aLine.end() ); |
|||
|
|||
// a comment line may be empty to improve human readability
|
|||
if( aLine.empty() && !isComment ) |
|||
return false; |
|||
|
|||
return true; |
|||
} |
|||
|
|||
|
|||
// extract an IDF string and move the index to point to the character after the substring
|
|||
bool IDF3::GetIDFString( const std::string& aLine, std::string& aIDFString, |
|||
bool& hasQuotes, int& aIndex ) |
|||
{ |
|||
// 1. drop all leading spaces
|
|||
// 2. if the first character is '"', read until the next '"',
|
|||
// otherwise read until the next space or EOL.
|
|||
|
|||
std::ostringstream ostr; |
|||
|
|||
int len = aLine.length(); |
|||
int idx = aIndex; |
|||
|
|||
if( idx < 0 || idx >= len ) |
|||
return false; |
|||
|
|||
while( isspace( aLine[idx] ) && idx < len ) ++idx; |
|||
|
|||
if( idx == len ) |
|||
{ |
|||
aIndex = idx; |
|||
return false; |
|||
} |
|||
|
|||
if( aLine[idx] == '"' ) |
|||
{ |
|||
hasQuotes = true; |
|||
++idx; |
|||
while( aLine[idx] != '"' && idx < len ) |
|||
ostr << aLine[idx++]; |
|||
|
|||
if( idx == len ) |
|||
{ |
|||
ERROR_IDF << "unterminated quote mark in line:\n"; |
|||
std::cerr << "LINE: " << aLine << "\n"; |
|||
aIndex = idx; |
|||
return false; |
|||
} |
|||
|
|||
++idx; |
|||
} |
|||
else |
|||
{ |
|||
hasQuotes = false; |
|||
|
|||
while( !isspace( aLine[idx] ) && idx < len ) |
|||
ostr << aLine[idx++]; |
|||
|
|||
} |
|||
|
|||
aIDFString = ostr.str(); |
|||
aIndex = idx; |
|||
|
|||
return true; |
|||
} |
|||
|
|||
|
|||
// perform a comparison between a fixed token string and an input string.
|
|||
// the token is assumed to be an upper case IDF token and the input string
|
|||
// is data from an IDF file. Since IDF tokens are case-insensitive, we cannot
|
|||
// assume anything about the case of the input string.
|
|||
bool IDF3::CompareToken( const char* aTokenString, const std::string& aInputString ) |
|||
{ |
|||
std::string::size_type i, j; |
|||
std::string bigToken = aInputString; |
|||
j = aInputString.length(); |
|||
|
|||
for( i = 0; i < j; ++i ) |
|||
bigToken[i] = std::toupper( bigToken[i] ); |
|||
|
|||
if( !bigToken.compare( aTokenString ) ) |
|||
return true; |
|||
|
|||
return false; |
|||
} |
|||
|
|||
|
|||
// parse a string for an IDF3::KEY_OWNER
|
|||
bool IDF3::ParseOwner( const std::string& aToken, IDF3::KEY_OWNER& aOwner ) |
|||
{ |
|||
if( CompareToken( "UNOWNED", aToken ) ) |
|||
{ |
|||
aOwner = UNOWNED; |
|||
return true; |
|||
} |
|||
else if( CompareToken( "ECAD", aToken ) ) |
|||
{ |
|||
aOwner = ECAD; |
|||
return true; |
|||
} |
|||
else if( CompareToken( "MCAD", aToken ) ) |
|||
{ |
|||
aOwner = MCAD; |
|||
return true; |
|||
} |
|||
|
|||
ERROR_IDF << "unrecognized IDF OWNER: '" << aToken << "'\n"; |
|||
|
|||
return false; |
|||
} |
|||
|
|||
|
|||
bool IDF3::ParseIDFLayer( const std::string& aToken, IDF3::IDF_LAYER& aLayer ) |
|||
{ |
|||
if( CompareToken( "TOP", aToken ) ) |
|||
{ |
|||
aLayer = LYR_TOP; |
|||
return true; |
|||
} |
|||
else if( CompareToken( "BOTTOM", aToken ) ) |
|||
{ |
|||
aLayer = LYR_BOTTOM; |
|||
return true; |
|||
} |
|||
else if( CompareToken( "BOTH", aToken ) ) |
|||
{ |
|||
aLayer = LYR_BOTH; |
|||
return true; |
|||
} |
|||
else if( CompareToken( "INNER", aToken ) ) |
|||
{ |
|||
aLayer = LYR_INNER; |
|||
return true; |
|||
} |
|||
else if( CompareToken( "ALL", aToken ) ) |
|||
{ |
|||
aLayer = LYR_ALL; |
|||
return true; |
|||
} |
|||
|
|||
ERROR_IDF << "unrecognized IDF LAYER: '" << aToken << "'\n"; |
|||
|
|||
aLayer = LYR_INVALID; |
|||
return false; |
|||
} |
|||
|
|||
|
|||
bool IDF3::WriteLayersText( std::ofstream& aBoardFile, IDF3::IDF_LAYER aLayer ) |
|||
{ |
|||
switch( aLayer ) |
|||
{ |
|||
case LYR_TOP: |
|||
aBoardFile << "TOP"; |
|||
break; |
|||
|
|||
case LYR_BOTTOM: |
|||
aBoardFile << "BOTTOM"; |
|||
break; |
|||
|
|||
case LYR_BOTH: |
|||
aBoardFile << "BOTH"; |
|||
break; |
|||
|
|||
case LYR_INNER: |
|||
aBoardFile << "INNER"; |
|||
break; |
|||
|
|||
case LYR_ALL: |
|||
aBoardFile << "ALL"; |
|||
break; |
|||
|
|||
default: |
|||
ERROR_IDF << "Invalid IDF layer" << aLayer << "\n"; |
|||
return false; |
|||
break; |
|||
} |
|||
|
|||
return !aBoardFile.fail(); |
|||
} |
|||
|
|||
|
|||
std::string IDF3::GetPlacementString( IDF3::IDF_PLACEMENT aPlacement ) |
|||
{ |
|||
switch( aPlacement ) |
|||
{ |
|||
case PS_UNPLACED: |
|||
return "UNPLACED"; |
|||
|
|||
case PS_PLACED: |
|||
return "PLACED"; |
|||
|
|||
case PS_MCAD: |
|||
return "MCAD"; |
|||
|
|||
case PS_ECAD: |
|||
return "ECAD"; |
|||
|
|||
default: |
|||
break; |
|||
} |
|||
|
|||
std::ostringstream ostr; |
|||
ostr << "[INVALID PLACEMENT VALUE]:" << aPlacement; |
|||
|
|||
return ostr.str(); |
|||
} |
|||
|
|||
|
|||
std::string IDF3::GetLayerString( IDF3::IDF_LAYER aLayer ) |
|||
{ |
|||
switch( aLayer ) |
|||
{ |
|||
case LYR_TOP: |
|||
return "TOP"; |
|||
|
|||
case LYR_BOTTOM: |
|||
return "BOTTOM"; |
|||
|
|||
case LYR_BOTH: |
|||
return "BOTH"; |
|||
|
|||
case LYR_INNER: |
|||
return "INNER"; |
|||
|
|||
case LYR_ALL: |
|||
return "ALL"; |
|||
|
|||
default: |
|||
break; |
|||
} |
|||
|
|||
std::ostringstream ostr; |
|||
ostr << "[INVALID LAYER VALUE]:" << aLayer; |
|||
|
|||
return ostr.str(); |
|||
} |
|||
@ -0,0 +1,171 @@ |
|||
/* |
|||
* This program source code file is part of KiCad, a free EDA CAD application. |
|||
* |
|||
* Copyright (C) 2014 Cirilo Bernardo |
|||
* |
|||
* This program is free software; you can redistribute it and/or |
|||
* modify it under the terms of the GNU General Public License |
|||
* as published by the Free Software Foundation; either version 2 |
|||
* of the License, or (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program; if not, you may find one here: |
|||
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html |
|||
* or you may search the http://www.gnu.org website for the version 2 license, |
|||
* or you may write to the Free Software Foundation, Inc., |
|||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA |
|||
*/ |
|||
|
|||
#ifndef IDF_HELPERS_H |
|||
#define IDF_HELPERS_H |
|||
|
|||
#include <wx/wx.h> |
|||
#include <fstream> |
|||
#include <string> |
|||
#include <idf_common.h> |
|||
|
|||
/** |
|||
* Macro TO_UTF8 |
|||
* converts a wxString to a UTF8 encoded C string for all wxWidgets build modes. |
|||
* wxstring is a wxString, not a wxT() or _(). The scope of the return value |
|||
* is very limited and volatile, but can be used with printf() style functions well. |
|||
* NOTE: Taken from KiCad include/macros.h |
|||
*/ |
|||
#define TO_UTF8( wxstring ) ( (const char*) (wxstring).utf8_str() ) |
|||
|
|||
/** |
|||
* function FROM_UTF8 |
|||
* converts a UTF8 encoded C string to a wxString for all wxWidgets build modes. |
|||
* NOTE: Taken from KiCad include/macros.h |
|||
*/ |
|||
static inline wxString FROM_UTF8( const char* cstring ) |
|||
{ |
|||
wxString line = wxString::FromUTF8( cstring ); |
|||
|
|||
if( line.IsEmpty() ) // happens when cstring is not a valid UTF8 sequence |
|||
line = wxConvCurrent->cMB2WC( cstring ); // try to use locale conversion |
|||
|
|||
return line; |
|||
} |
|||
|
|||
|
|||
#define ERROR_IDF std::cerr << "* " << __FILE__ << ":" << __LINE__ << ":" << __FUNCTION__ << "(): " |
|||
|
|||
// minimum drill diameters / slot widths to be represented in the IDF output |
|||
#define IDF_MIN_DIA_MM ( 0.001 ) |
|||
#define IDF_MIN_DIA_THOU ( 0.00039 ) |
|||
|
|||
// conversion between mm and thou |
|||
#define IDF_MM_TO_THOU 0.0254 |
|||
|
|||
namespace IDF3 |
|||
{ |
|||
|
|||
/** |
|||
* Function FetchIDFLine |
|||
* retrieves a single line from an IDF file and performs minimal processing. If a comment symbol |
|||
* is encountered then it is removed and a single leading space is removed if present; all trailing |
|||
* spaces are removed. If the line is not a comment then all leading and trailing spaces are stripped. |
|||
* |
|||
* @param aModel is an open IDFv3 file |
|||
* @param aLine (output) is the line retrieved from the file |
|||
* @param isComment (output) is set to true if the line is a comment |
|||
* @param aFilePos (output) is set to the beginning of the line in case the file needs to be rewound |
|||
* |
|||
* @return bool: true if a line was read and was not empty; otherwise false |
|||
*/ |
|||
bool FetchIDFLine( std::ifstream& aModel, std::string& aLine, bool& isComment, std::streampos& aFilePos ); |
|||
|
|||
|
|||
/** |
|||
* Function GetIDFString |
|||
* parses a line retrieved via FetchIDFLine() and returns the first IDF string found from the starting |
|||
* point aIndex |
|||
* |
|||
* @param aLine is the line to parse |
|||
* @param aIDFString (output) is the IDF string retrieved |
|||
* @param hasQuotes (output) is true if the string was in quotation marks |
|||
* @param aIndex (input/output) is the index into the input line |
|||
* |
|||
* @return bool: true if a string was retrieved, otherwise false |
|||
*/ |
|||
bool GetIDFString( const std::string& aLine, std::string& aIDFString, |
|||
bool& hasQuotes, int& aIndex ); |
|||
|
|||
/** |
|||
* Function CompareToken |
|||
* performs a case-insensitive comparison of a token string and an input string |
|||
* |
|||
* @param aToken is an IDF token such as ".HEADER" |
|||
* @param aInputString is a string typically retrieved via GetIDFString |
|||
* |
|||
* @return bool: true if the token and input string match |
|||
*/ |
|||
bool CompareToken( const char* aTokenString, const std::string& aInputString ); |
|||
|
|||
|
|||
/** |
|||
* Function ParseOwner |
|||
* parses the input string for a valid IDF Owner type |
|||
* |
|||
* @param aToken is the string to be parsed |
|||
* @param aOwner (output) is the IDF Owner class |
|||
* |
|||
* @return bool: true if a valid OWNER was found, otherwise false |
|||
*/ |
|||
bool ParseOwner( const std::string& aToken, IDF3::KEY_OWNER& aOwner ); |
|||
|
|||
|
|||
/** |
|||
* Function ParseIDFLayer |
|||
* parses an input string for a valid IDF layer specification |
|||
* |
|||
* @param aToken is the string to be parsed |
|||
* @param aLayer (output) is the IDF Layer type or group |
|||
* |
|||
* @return bool: true if a valid IDF Layer type was found, otherwise false |
|||
*/ |
|||
bool ParseIDFLayer( const std::string& aToken, IDF3::IDF_LAYER& aLayer ); |
|||
|
|||
|
|||
/** |
|||
* Function WriteLayersText |
|||
* writes out text corresponding to the given IDF Layer type |
|||
* |
|||
* @param aBoardFile is an IDFv3 file open for output |
|||
* @param aLayer is the IDF Layer type |
|||
* |
|||
* @return bool: true if the data was successfully written, otherwise false |
|||
*/ |
|||
bool WriteLayersText( std::ofstream& aBoardFile, IDF3::IDF_LAYER aLayer ); |
|||
|
|||
|
|||
/** |
|||
* Function GetPlacementString |
|||
* returns a string representing the given IDF Placement type |
|||
* |
|||
* @param aPlacement is the IDF placement type to encode as a string |
|||
* |
|||
* @return string: the string representation of aPlacement |
|||
*/ |
|||
std::string GetPlacementString( IDF3::IDF_PLACEMENT aPlacement ); |
|||
|
|||
|
|||
/** |
|||
* Function GetLayerString |
|||
* returns a string representing the given IDF Layer type |
|||
* |
|||
* @param aLayer is the IDF layer type to encode as a string |
|||
* |
|||
* @return string: the string representation of aLayer |
|||
*/ |
|||
std::string GetLayerString( IDF3::IDF_LAYER aLayer ); |
|||
|
|||
} |
|||
|
|||
#endif // IDF_HELPERS_H |
|||
2614
utils/idftools/idf_outlines.cpp
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,754 @@ |
|||
/* |
|||
* This program source code file is part of KiCad, a free EDA CAD application. |
|||
* |
|||
* Copyright (C) 2014 Cirilo Bernardo |
|||
* |
|||
* This program is free software; you can redistribute it and/or |
|||
* modify it under the terms of the GNU General Public License |
|||
* as published by the Free Software Foundation; either version 2 |
|||
* of the License, or (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program; if not, you may find one here: |
|||
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html |
|||
* or you may search the http://www.gnu.org website for the version 2 license, |
|||
* or you may write to the Free Software Foundation, Inc., |
|||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA |
|||
*/ |
|||
|
|||
|
|||
#ifndef IDF_OUTLINES_H |
|||
#define IDF_OUTLINES_H |
|||
|
|||
#include <string> |
|||
#include <list> |
|||
#include <map> |
|||
#include <wx/string.h> |
|||
#include <wx/filename.h> |
|||
|
|||
#include <idf_common.h> |
|||
|
|||
/* |
|||
* NOTES ON OUTLINE TYPES: |
|||
* |
|||
* BOARD_OUTLINE (PANEL_OUTLINE) |
|||
* .BOARD_OUTLINE [OWNER] |
|||
* [thickness] |
|||
* [outlines] |
|||
* |
|||
* OTHER_OUTLINE |
|||
* .OTHER_OUTLINE [OWNER] |
|||
* [outline identifier] [thickness] [board side: Top/Bot] |
|||
* [outline] |
|||
* |
|||
* ROUTE_OUTLINE |
|||
* .ROUTE_OUTLINE [OWNER] |
|||
* [layers] |
|||
* [outline] |
|||
* |
|||
* PLACE_OUTLINE |
|||
* .PLACE_OUTLINE [OWNER] |
|||
* [board side: Top/Bot/Both] [height] |
|||
* [outline] |
|||
* |
|||
* ROUTE_KEEPOUT |
|||
* .ROUTE_KEEPOUT [OWNER] |
|||
* [layers] |
|||
* [outline] |
|||
* |
|||
* VIA_KEEPOUT |
|||
* .VIA_KEEPOUT [OWNER] |
|||
* [outline] |
|||
* |
|||
* PLACE_KEEPOUT |
|||
* .PLACE_KEEPOUT [OWNER] |
|||
* [board side: Top/Bot/Both] [height] |
|||
* [outline] |
|||
* |
|||
* Placement Group |
|||
* .PLACE_REGION [OWNER] |
|||
* [side: Top/Bot/Both ] [component group name] |
|||
* [outline] |
|||
* |
|||
* Component Outline: |
|||
* .ELECTRICAL/.MECHANICAL |
|||
* [GEOM] [PART] [UNIT] [HEIGHT] |
|||
* [outline] |
|||
* [PROP] [prop name] [prop value] |
|||
*/ |
|||
|
|||
class IDF3_BOARD; |
|||
|
|||
|
|||
/** |
|||
* Class BOARD_OUTLINE |
|||
* supports the IDFv3 BOARD OUTLINE data and is the basis of other IDFv3 outline classes |
|||
*/ |
|||
class BOARD_OUTLINE |
|||
{ |
|||
protected: |
|||
std::list< IDF_OUTLINE* > outlines; |
|||
IDF3::KEY_OWNER owner; // indicates the owner of this outline (MCAD, ECAD, UNOWNED) |
|||
IDF3::OUTLINE_TYPE outlineType;// type of IDF outline |
|||
bool single; // true if only a single outline is accepted |
|||
std::list< std::string > comments; // associated comment list |
|||
IDF3::IDF_UNIT unit; // outline's native unit (MM or THOU) |
|||
IDF3_BOARD* parent; // BOARD which contains this outline |
|||
double thickness; // Board/Extrude Thickness or Height (IDF spec) |
|||
|
|||
// Read outline data from a BOARD or LIBRARY file's outline section |
|||
bool readOutlines( std::ifstream& aBoardFile ); |
|||
// Write comments to a BOARD or LIBRARY file (must not be within a SECTION as per IDFv3 spec) |
|||
bool writeComments( std::ofstream& aBoardFile ); |
|||
// Write the outline owner to a BOARD file |
|||
bool writeOwner( std::ofstream& aBoardFile ); |
|||
// Write the data of a single outline object |
|||
bool writeOutline( std::ofstream& aBoardFile, IDF_OUTLINE* aOutline, size_t aIndex ); |
|||
// Iterate through the outlines and write out all data |
|||
bool writeOutlines( std::ofstream& aBoardFile ); // write outline data (no headers) |
|||
|
|||
public: |
|||
BOARD_OUTLINE(); |
|||
virtual ~BOARD_OUTLINE(); |
|||
|
|||
/** |
|||
* Function SetUnit |
|||
* sets the native unit of the outline; except for component outlines this must |
|||
* be the same as the native unit of the parent IDF_BOARD object |
|||
* |
|||
* @param aUnit is the native unit (UNIT_MM or UNIT_THOU) |
|||
*/ |
|||
virtual void SetUnit( IDF3::IDF_UNIT aUnit ); |
|||
|
|||
/** |
|||
* Function GetUnit |
|||
* returns the native unit type of the outline |
|||
* |
|||
* @return IDF_UNIT is the native unit (UNIT_MM or UNIT_THOU) |
|||
*/ |
|||
virtual IDF3::IDF_UNIT GetUnit( void ); |
|||
|
|||
/** |
|||
* Function SetThickness |
|||
* sets the thickness or height of the outline (mm) |
|||
* |
|||
* @param aThickness is the thickness or height of the outline in mm |
|||
*/ |
|||
virtual bool SetThickness( double aThickness ); |
|||
|
|||
/** |
|||
* Function GetThickness |
|||
* returns the thickness or height of an outline (mm) |
|||
*/ |
|||
virtual double GetThickness( void ); |
|||
|
|||
/** |
|||
* Function ReadData |
|||
* reads data from a .BOARD_OUTLINE section |
|||
* |
|||
* @param aBoardFile is an IDFv3 file opened for reading |
|||
* @param aHeader is the ".BOARD_OUTLINE" header line as read by FetchIDFLine |
|||
* |
|||
* @return bool: true if the BOARD_OUTLINE section was successfully read, otherwise |
|||
* false. In case of an unrecoverable error an exception is thrown. On a successful |
|||
* return the file pointer will be at the line following .END_BOARD_OUTLINE |
|||
*/ |
|||
virtual bool ReadData( std::ifstream& aBoardFile, const std::string& aHeader ); |
|||
|
|||
/** |
|||
* Function WriteData |
|||
* writes the comments and .BOARD_OUTLINE section to an IDFv3 file |
|||
* |
|||
* @param aBoardFile is an IDFv3 file opened for writing |
|||
* |
|||
* @return bool: true if the data had been successfully written, otherwise false. |
|||
*/ |
|||
virtual bool WriteData( std::ofstream& aBoardFile ); |
|||
|
|||
/** |
|||
* Function Clear |
|||
* frees memory and reinitializes all internal data except for the parent pointer |
|||
*/ |
|||
virtual void Clear( void ); |
|||
|
|||
/** |
|||
* Function GetOutlineType |
|||
* returns the type of outline according to the IDFv3 classification |
|||
*/ |
|||
IDF3::OUTLINE_TYPE GetOutlineType( void ); |
|||
|
|||
/** |
|||
* Function SetParent |
|||
* sets the parent IDF_BOARD object |
|||
*/ |
|||
void SetParent( IDF3_BOARD* aParent ); |
|||
|
|||
/** |
|||
* Function GetParent |
|||
* returns the parent IDF_BOARD object |
|||
*/ |
|||
IDF3_BOARD* GetParent( void ); |
|||
|
|||
|
|||
/** |
|||
* Function AddOutline |
|||
* adds the specified outline to this object. |
|||
* |
|||
* @param aOutline is a valid IDF outline |
|||
* |
|||
* @return bool: true if the outline was added; false if the outline |
|||
* already existed. If the outline cannot be added due to a violation |
|||
* of the IDF specification (multiple outlines for anything other than |
|||
* a BOARD_OUTLINE, or the ownership rules are violated) an exception is |
|||
* thrown. |
|||
*/ |
|||
bool AddOutline( IDF_OUTLINE* aOutline ); |
|||
|
|||
/** |
|||
* Function DelOutline( IDF_OUTLINE* aOutline ) |
|||
* removes the given outline, subject to IDF ownership rules, |
|||
* if it is owned by this object. The outline pointer remains |
|||
* valid and it is the user's responsibility to delete the object. |
|||
* The first outline in the list will never be deleted unless it |
|||
* is the sole remaining outline; this is to ensure that a board |
|||
* outline is not removed while the cutouts remain. |
|||
* |
|||
* @param aOutline is a pointer to the outline to remove from the list |
|||
* |
|||
* @return bool: true if the outline was found and removed; false if |
|||
* the outline was not found. If an ownership violation occurs an |
|||
* exception is thrown. |
|||
*/ |
|||
bool DelOutline( IDF_OUTLINE* aOutline ); |
|||
|
|||
/** |
|||
* Function DelOutline( IDF_OUTLINE* aOutline ) |
|||
* deletes the outline specified by the given index, subject to |
|||
* IDF ownership rules. The outline data is destroyed. |
|||
* The first outline in the list will never be deleted unless it |
|||
* is the sole remaining outline; this is to ensure that a board |
|||
* outline is not removed while the cutouts remain. |
|||
* |
|||
* @param aIndex is an index to the outline to delete |
|||
* |
|||
* @return bool: true if the outline was found and deleted; false if |
|||
* the outline was not found. If an ownership violation or indexation |
|||
* error occurs an exception is thrown. |
|||
*/ |
|||
bool DelOutline( size_t aIndex ); |
|||
|
|||
/** |
|||
* Function GetOutlines |
|||
* returns a pointer to the internal outlines list. It is up to the |
|||
* user to respect the IDFv3 specification and avoid changes to this |
|||
* list which are in violation of the specification. |
|||
*/ |
|||
const std::list< IDF_OUTLINE* >*const GetOutlines( void ); |
|||
|
|||
/** |
|||
* Function OutlinesSize |
|||
* returns the number of items in the internal outline list |
|||
*/ |
|||
size_t OutlinesSize( void ); |
|||
|
|||
/** |
|||
* Function GetOutline |
|||
* returns a pointer to the outline as specified by aIndex. |
|||
* If the index is out of bounds an error is thrown. It is the |
|||
* responsibility of the user to observe IDF ownership rules. |
|||
*/ |
|||
IDF_OUTLINE* GetOutline( size_t aIndex ); |
|||
|
|||
/** |
|||
* Function GetOwner |
|||
* returns the ownership status of the outline ( ECAD, MCAD, UNOWNED) |
|||
*/ |
|||
IDF3::KEY_OWNER GetOwner( void ); |
|||
|
|||
/** |
|||
* Function SetOwner |
|||
* sets the ownership status of the outline subject to IDF |
|||
* ownership rules. The return value is true if the ownership |
|||
* was changed and false if a specification violation occurred. |
|||
*/ |
|||
bool SetOwner( IDF3::KEY_OWNER aOwner ); |
|||
|
|||
/** |
|||
* Function IsSingle |
|||
* return true if this type of outline only supports a single |
|||
* outline. All outlines except for BOARD_OUTLINE are single. |
|||
*/ |
|||
bool IsSingle( void ); |
|||
|
|||
/** |
|||
* Function ClearOutlines |
|||
* clears internal data except for the parent pointer |
|||
*/ |
|||
void ClearOutlines( void ); |
|||
|
|||
/** |
|||
* Function AddComment |
|||
* adds a comment to the outline data; this function is not |
|||
* subject to IDF ownership rules. |
|||
*/ |
|||
void AddComment( const std::string& aComment ); |
|||
|
|||
/** |
|||
* Function CommentSize |
|||
* returns the number of comments in the internal list |
|||
*/ |
|||
size_t CommentsSize( void ); |
|||
|
|||
/** |
|||
* Function GetComments |
|||
* returns a pointer to the internal list of comments |
|||
*/ |
|||
std::list< std::string >* GetComments( void ); |
|||
|
|||
/** |
|||
* Function GetComment |
|||
* returns the string representing the indexed comment or |
|||
* NULL if the index is out of bounds |
|||
*/ |
|||
const std::string* GetComment( size_t aIndex ); |
|||
|
|||
/** |
|||
* Function DeleteComment |
|||
* deletes a comment based on the given index. |
|||
* |
|||
* @return bool: true if a comment was deleted, false if |
|||
* the index is out of bounds. |
|||
*/ |
|||
bool DeleteComment( size_t aIndex ); |
|||
|
|||
/** |
|||
* Function ClearComments |
|||
* deletes all comments |
|||
*/ |
|||
void ClearComments( void ); |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* Class OTHER_OUTLINE |
|||
* describes miscellaneous extrusions on the board |
|||
*/ |
|||
class OTHER_OUTLINE : public BOARD_OUTLINE |
|||
{ |
|||
private: |
|||
std::string uniqueID; // Outline Identifier (IDF spec) |
|||
IDF3::IDF_LAYER side; // Board Side [TOP/BOTTOM ONLY] (IDF spec) |
|||
|
|||
public: |
|||
OTHER_OUTLINE(); |
|||
|
|||
/** |
|||
* Function SetOutlineIdentifier |
|||
* sets the Outline Identifier string of this OTHER_OUTLINE object |
|||
* as per IDFv3 spec. |
|||
*/ |
|||
virtual void SetOutlineIdentifier( const std::string aUniqueID ); |
|||
|
|||
/** |
|||
* Function GetOutlineIdentifier |
|||
* returns the object's Outline Identifier |
|||
*/ |
|||
virtual const std::string& GetOutlineIdentifier( void ); |
|||
|
|||
/** |
|||
* Function SetSide |
|||
* sets the side which this outline is applicable to (TOP, BOTTOM). |
|||
* |
|||
* @return bool: true if the side was set, false if the side is invalid. |
|||
* An exception is thrown if there is a violation of IDF ownership rules. |
|||
*/ |
|||
virtual bool SetSide( IDF3::IDF_LAYER aSide ); |
|||
|
|||
/** |
|||
* Function GetSide |
|||
* returns the side which this outline is applicable to |
|||
*/ |
|||
virtual IDF3::IDF_LAYER GetSide( void ); |
|||
|
|||
/** |
|||
* Function ReadData |
|||
* reads an OTHER_OUTLINE data from an IDFv3 file. |
|||
* |
|||
* @param aBoardFile is an IDFv3 file open for reading |
|||
* @param aHeader is the .OTHER_OUTLINE header as read via FetchIDFLine |
|||
* |
|||
* @return bool: true if data was read, otherwise false. If an unrecoverable |
|||
* error occurs an exception is thrown. |
|||
*/ |
|||
virtual bool ReadData( std::ifstream& aBoardFile, const std::string& aHeader ); |
|||
|
|||
/** |
|||
* Function WriteData |
|||
* writes the OTHER_OUTLINE data to an open IDFv3 file |
|||
* |
|||
* @param aBoardFile is an IDFv3 file open for writing |
|||
* |
|||
* @return bool: true if the data was successfully written, otherwise false. |
|||
*/ |
|||
virtual bool WriteData( std::ofstream& aBoardFile ); |
|||
|
|||
/** |
|||
* Function Clear |
|||
* deletes internal data except for the parent object |
|||
*/ |
|||
virtual void Clear( void ); |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* Class ROUTE_OUTLINE |
|||
* describes routing areas on the board |
|||
*/ |
|||
class ROUTE_OUTLINE : public BOARD_OUTLINE |
|||
{ |
|||
protected: |
|||
IDF3::IDF_LAYER layers; // Routing layers (IDF spec) |
|||
|
|||
public: |
|||
ROUTE_OUTLINE(); |
|||
|
|||
/** |
|||
* Function SetLayers |
|||
* sets the layer or group of layers this outline is applicable to. |
|||
* This function is subject to IDF ownership rules. An exception is |
|||
* thrown if an invalid layer is provided or an IDF ownership violation |
|||
* occurs. |
|||
*/ |
|||
virtual void SetLayers( IDF3::IDF_LAYER aLayer ); |
|||
|
|||
/** |
|||
* Function GetLayers |
|||
* returns the layer or group of layers which this outline is applicable to |
|||
*/ |
|||
virtual IDF3::IDF_LAYER GetLayers( void ); |
|||
|
|||
/** |
|||
* Function ReadData |
|||
* reads ROUTE_OUTLINE data from an IDFv3 file |
|||
* |
|||
* @param aBoardFile is an open IDFv3 board file |
|||
* @param aHeader is the .ROUTE_OUTLINE header as returned by FetchIDFLine |
|||
* |
|||
* @return bool: true if data was read, otherwise false. If unrecoverable |
|||
* errors occur an exception is thrown. |
|||
*/ |
|||
virtual bool ReadData( std::ifstream& aBoardFile, const std::string& aHeader ); |
|||
|
|||
/** |
|||
* Function WriteData |
|||
* writes the ROUTE_OUTLINE data to an open IDFv3 file |
|||
*/ |
|||
virtual bool WriteData( std::ofstream& aBoardFile ); |
|||
|
|||
/** |
|||
* Function Clear |
|||
* deletes internal data except for the parent object |
|||
*/ |
|||
virtual void Clear( void ); |
|||
}; |
|||
|
|||
/** |
|||
* Class PLACE_OUTLINE |
|||
* describes areas on the board for placing components |
|||
*/ |
|||
class PLACE_OUTLINE : public BOARD_OUTLINE |
|||
{ |
|||
protected: |
|||
IDF3::IDF_LAYER side; // Board Side [TOP/BOTTOM/BOTH ONLY] (IDF spec) |
|||
double height; // Max Height (IDF spec) |
|||
|
|||
public: |
|||
PLACE_OUTLINE(); |
|||
|
|||
/** |
|||
* Function SetSide |
|||
* sets the side (TOP, BOTTOM, BOTH) which this outline applies to, |
|||
* subject to IDF ownership rules. An exception is thrown if there is |
|||
* an ownership violation or an invalid layer is passed. |
|||
*/ |
|||
virtual void SetSide( IDF3::IDF_LAYER aSide ); |
|||
|
|||
/** |
|||
* Function GetSide |
|||
* returns the side which this outline is applicable to |
|||
*/ |
|||
virtual IDF3::IDF_LAYER GetSide( void ); |
|||
|
|||
/** |
|||
* Function SetMaxHeight |
|||
* sets the maximum height of a component within this outline, |
|||
* subject to IDF ownership rules. An exception is thrown if |
|||
* there is an ownership violation or aHeight is negative. |
|||
*/ |
|||
virtual void SetMaxHeight( double aHeight ); |
|||
|
|||
/** |
|||
* Function GetMaxHeight |
|||
* returns the maximum allowable height for a component in this region |
|||
*/ |
|||
virtual double GetMaxHeight( void ); |
|||
|
|||
/** |
|||
* Function ReadData |
|||
* reads PLACE_OUTLINE data from an open IDFv3 file. |
|||
* |
|||
* @param aBoardFile is an IDFv3 file opened for reading |
|||
* @param aHeader is the .PLACE_OUTLINE header as returned by FetchIDFLine |
|||
* |
|||
* @return bool: true if data was read, otherwise false. If there are |
|||
* unrecoverable errors an exception is thrown. |
|||
*/ |
|||
virtual bool ReadData( std::ifstream& aBoardFile, const std::string& aHeader ); |
|||
|
|||
/** |
|||
* Function WriteData |
|||
* writes the PLACE_OUTLINE data to an open IDFv3 file |
|||
* |
|||
* @param aBoardFile is an IDFv3 file opened for writing |
|||
* |
|||
* @return bool: true if the data was successfully written, otherwise false |
|||
*/ |
|||
virtual bool WriteData( std::ofstream& aBoardFile ); |
|||
|
|||
/** |
|||
* Function Clear |
|||
* deletes all internal data |
|||
*/ |
|||
virtual void Clear( void ); |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* Class ROUTE_KO_OUTLINE |
|||
* describes regions and layers where no electrical routing is permitted |
|||
*/ |
|||
class ROUTE_KO_OUTLINE : public ROUTE_OUTLINE |
|||
{ |
|||
public: |
|||
ROUTE_KO_OUTLINE(); |
|||
}; |
|||
|
|||
/** |
|||
* Class VIA_KO_OUTLINE |
|||
* describes regions in which vias are prohibited. Note: IDFv3 only considers |
|||
* thru-hole vias and makes no statement regarding behavior with blind or buried |
|||
* vias. |
|||
*/ |
|||
class VIA_KO_OUTLINE : public OTHER_OUTLINE |
|||
{ |
|||
public: |
|||
VIA_KO_OUTLINE(); |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* Class PLACE_KO_OUTLINE |
|||
* represents regions and layers in which no component may |
|||
* be placed or on which a maximum component height is in effect. |
|||
*/ |
|||
class PLACE_KO_OUTLINE : public PLACE_OUTLINE |
|||
{ |
|||
public: |
|||
PLACE_KO_OUTLINE(); |
|||
}; |
|||
|
|||
/** |
|||
* Class GROUP_OUTLINE |
|||
* represents regions and layers in which user-specified features or components |
|||
* may be placed. |
|||
*/ |
|||
class GROUP_OUTLINE : public BOARD_OUTLINE |
|||
{ |
|||
private: |
|||
IDF3::IDF_LAYER side; // Board Side [TOP/BOTTOM/BOTH ONLY] (IDF spec) |
|||
std::string groupName; // non-unique string |
|||
|
|||
public: |
|||
GROUP_OUTLINE(); |
|||
|
|||
/** |
|||
* Function SetSide |
|||
* sets the side which this outline applies to (TOP, BOTTOM, BOTH), |
|||
* subject to IDF ownership rules. If an ownership violation occurs |
|||
* or an invalid side is specified, an exception is thrown. |
|||
*/ |
|||
virtual void SetSide( IDF3::IDF_LAYER aSide ); |
|||
|
|||
/** |
|||
* Function GetSide |
|||
* returns the side which this outline applies to |
|||
*/ |
|||
virtual IDF3::IDF_LAYER GetSide( void ); |
|||
|
|||
/** |
|||
* Function SetGroupName |
|||
* sets the name of the group, subject to IDF ownership rules. |
|||
* An empty name or an ownership violation results in a thrown |
|||
* exception. |
|||
*/ |
|||
virtual void SetGroupName( std::string aGroupName ); |
|||
|
|||
/** |
|||
* Function GetGroupName |
|||
* returns a reference to the (non-unique) group name |
|||
*/ |
|||
virtual const std::string& GetGroupName( void ); |
|||
|
|||
/** |
|||
* Function ReadData |
|||
* reads GROUP_OUTLINE data from an open IDFv3 file |
|||
* |
|||
* @param aBoardFile is an open IDFv3 file |
|||
* @param aHeader is the .PLACE_REGION header as returned by FetchIDFLine |
|||
* |
|||
* @return bool: true if data was read, otherwise false. If an unrecoverable |
|||
* error occurs an exception is thrown. |
|||
*/ |
|||
virtual bool ReadData( std::ifstream& aBoardFile, const std::string& aHeader ); |
|||
|
|||
/** |
|||
* Function WriteData |
|||
* writes the data to a .PLACE_REGION section of an IDFv3 file |
|||
* |
|||
* @param aBoardFile is an IDFv3 file open for writing |
|||
* |
|||
* @return bool: true if the data is successfully written, otherwise false |
|||
*/ |
|||
virtual bool WriteData( std::ofstream& aBoardFile ); |
|||
|
|||
/** |
|||
* Function Clear |
|||
* deletes internal data, subject to IDF ownership rules |
|||
*/ |
|||
virtual void Clear( void ); |
|||
}; |
|||
|
|||
|
|||
/** |
|||
* class IDF3_COMP_OUTLINE |
|||
* represents a component's outline as stored in an IDF library file |
|||
*/ |
|||
class IDF3_COMP_OUTLINE : public BOARD_OUTLINE |
|||
{ |
|||
private: |
|||
std::string uid; // unique ID |
|||
std::string geometry; // geometry name (IDF) |
|||
std::string part; // part name (IDF) |
|||
IDF3::COMP_TYPE compType; // component type |
|||
int refNum; // number of components referring to this outline |
|||
|
|||
std::map< std::string, std::string > props; // properties list |
|||
|
|||
bool readProperties( std::ifstream& aLibFile ); |
|||
bool writeProperties( std::ofstream& aLibFile ); |
|||
|
|||
public: |
|||
IDF3_COMP_OUTLINE(); |
|||
|
|||
/** |
|||
* Function ReadData |
|||
* reads a component outline from an open IDFv3 file |
|||
* |
|||
* @param aLibFile is an open IDFv3 Library file |
|||
* @param aHeader is the .ELECTRICAL or .MECHANICAL header as returned by FetchIDFLine |
|||
* |
|||
* @return bool: true if data was read, otherwise false. If unrecoverable errors |
|||
* occur, an exception is thrown. |
|||
*/ |
|||
virtual bool ReadData( std::ifstream& aLibFile, const std::string& aHeader ); |
|||
|
|||
/** |
|||
* Function WriteData |
|||
* writes comments and component outline data to an IDFv3 Library file |
|||
* |
|||
* @param aLibFile is an IDFv3 library file open for writing |
|||
* |
|||
* @return bool: true if the data was successfully written, otherwise false |
|||
*/ |
|||
virtual bool WriteData( std::ofstream& aLibFile ); |
|||
|
|||
/** |
|||
* Function Clear |
|||
* deletes internal outline data |
|||
*/ |
|||
virtual void Clear( void ); |
|||
|
|||
/** |
|||
* Function SetComponentClass |
|||
* sets the type of component outline (.ELECTRICAL or .MECHANICAL) |
|||
* If the specified class is invalid an exception is thrown. |
|||
*/ |
|||
void SetComponentClass( IDF3::COMP_TYPE aCompClass ); |
|||
|
|||
/** |
|||
* Function GetComponentClass |
|||
* returns the class of component represented by this outline |
|||
*/ |
|||
IDF3::COMP_TYPE GetComponentClass( void ); |
|||
|
|||
/** |
|||
* Function SetGeomName |
|||
* sets the Geometry Name (Package Name, IDFv3 spec) of the component outline |
|||
*/ |
|||
void SetGeomName( const std::string& aGeomName ); |
|||
|
|||
/** |
|||
* Function GetGeomName |
|||
* returns the Geometry Name (Package Name) of the component outline |
|||
*/ |
|||
const std::string& GetGeomName( void ); |
|||
|
|||
/** |
|||
* Function SetPartName |
|||
* sets the Part Name (Part Number, IDFv3 spec) of the component outline |
|||
*/ |
|||
void SetPartName( const std::string& aPartName ); |
|||
|
|||
/** |
|||
* Function GetPartName |
|||
* returns the Part Name (Part Number) of the component outline |
|||
*/ |
|||
const std::string& GetPartName( void ); |
|||
|
|||
/** |
|||
* Function GetUID |
|||
* returns the unique identifier for this component outline; |
|||
* this is equal to GEOM_NAME + "_" + PART_NAME |
|||
*/ |
|||
const std::string& GetUID( void ); |
|||
|
|||
/** |
|||
* Function IncrementRef |
|||
* increments the internal reference counter to keep track of the number of |
|||
* components referring to this outline. |
|||
*/ |
|||
int IncrementRef( void ); |
|||
|
|||
/** |
|||
* Function DecrementRef |
|||
* decrements the internal reference counter to keep track of the number of |
|||
* components referring to this outline. |
|||
*/ |
|||
int DecrementRef( void ); |
|||
|
|||
/** |
|||
* Function CreateDefaultOutline |
|||
* creates a default outline with the given Geometry and Part names. |
|||
* This outline is a star with outer radius 5mm and inner radius 2.5mm. |
|||
*/ |
|||
bool CreateDefaultOutline( const std::string &aGeom, const std::string &aPart ); |
|||
|
|||
// XXX: property manipulators |
|||
}; |
|||
|
|||
#endif // IDF_OUTLINES_H |
|||
3819
utils/idftools/idf_parser.cpp
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,657 @@ |
|||
/* |
|||
* This program source code file is part of KiCad, a free EDA CAD application. |
|||
* |
|||
* Copyright (C) 2014 Cirilo Bernardo |
|||
* |
|||
* This program is free software; you can redistribute it and/or |
|||
* modify it under the terms of the GNU General Public License |
|||
* as published by the Free Software Foundation; either version 2 |
|||
* of the License, or (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program; if not, you may find one here: |
|||
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html |
|||
* or you may search the http://www.gnu.org website for the version 2 license, |
|||
* or you may write to the Free Software Foundation, Inc., |
|||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA |
|||
*/ |
|||
|
|||
// NOTE: |
|||
// 1. Due to the complexity of objects and the risk of accumulated |
|||
// position errors, CAD packages should only delete or add complete |
|||
// components. If a component being added already exists, it is |
|||
// replaced by the new component IF and only if the CAD type is |
|||
// permitted to make such changes. |
|||
// |
|||
// 2. Internally all units shall be in mm and by default we shall |
|||
// write files with mm units. The internal flags mm/thou shall only |
|||
// be used to translate data being read from or written to files. |
|||
// This avoids the painful management of a mixture of mm and thou. |
|||
// The API shall require all dimensions in mm; for people using any |
|||
// other unit, it is their responsibility to perform the conversion |
|||
// to mm. Conversion back to thou may incur small rounding errors. |
|||
|
|||
// BUGS: |
|||
// 1. IDF compliance: On DELETE operations, ensure that the CAD |
|||
// has permission to make these deletions. This is no small task; |
|||
// however this compliance task can be deferred since it is not |
|||
// essential to the immediate needs of KiCad which are IDF |
|||
// export and IDF->VRML conversion |
|||
|
|||
#ifndef IDF_PARSER_H |
|||
#define IDF_PARSER_H |
|||
|
|||
#include <idf_outlines.h> |
|||
|
|||
class IDF3_COMPONENT; |
|||
|
|||
class IDF3_COMP_OUTLINE_DATA |
|||
{ |
|||
private: |
|||
double xoff; // X offset from KiCad or X placement from IDF file |
|||
double yoff; // Y offset from KiCad or Y placement from IDF file |
|||
double zoff; // height offset (specified in IDFv3 spec, corresponds to KiCad Z offset) |
|||
double aoff; // angular offset from KiCad or Rotation Angle from IDF file |
|||
|
|||
IDF3_COMP_OUTLINE* outline; // component outline to use |
|||
IDF3_COMPONENT* parent; // associated component |
|||
|
|||
public: |
|||
/** |
|||
* Constructor |
|||
* creates an object with default settings and no parent or associated outline |
|||
*/ |
|||
IDF3_COMP_OUTLINE_DATA(); |
|||
|
|||
/** |
|||
* Constructor |
|||
* creates an object with default settings and the specified parent and associated outline |
|||
* |
|||
* @param aParent is the owning IDF3_COMPONENT object |
|||
* @param aOutline is the outline for this placed component |
|||
*/ |
|||
IDF3_COMP_OUTLINE_DATA( IDF3_COMPONENT* aParent, IDF3_COMP_OUTLINE* aOutline ); |
|||
|
|||
/** |
|||
* Constructor |
|||
* creates an object the specified parent and associated outline and the specified |
|||
* data. |
|||
* |
|||
* @param aParent is the owning IDF3_COMPONENT object |
|||
* @param aOutline is the outline for this placed component |
|||
* @param aXoff is the X offset of this outline in relation to its parent |
|||
* @param aYoff is the Y offset of this outline in relation to its parent |
|||
* @param aZoff is the board offset of this outline as per IDFv3 specification |
|||
* @param aAoff is the rotational offset of this outline in relation to its parent |
|||
*/ |
|||
IDF3_COMP_OUTLINE_DATA( IDF3_COMPONENT* aParent, IDF3_COMP_OUTLINE* aOutline, |
|||
double aXoff, double aYoff, double aZoff, double aAngleOff ); |
|||
|
|||
~IDF3_COMP_OUTLINE_DATA(); |
|||
|
|||
/** |
|||
* Function SetOffsets |
|||
* sets the position and orientation of this outline item in relation to its parent |
|||
* |
|||
* @param aXoff is the X offset of this outline in relation to its parent |
|||
* @param aYoff is the Y offset of this outline in relation to its parent |
|||
* @param aZoff is the board offset of this outline as per IDFv3 specification |
|||
* @param aAoff is the rotational offset of this outline in relation to its parent |
|||
*/ |
|||
void SetOffsets( double aXoff, double aYoff, double aZoff, double aAngleOff ); |
|||
|
|||
/** |
|||
* Function GetOffsets |
|||
* retrieves the position and orientation of this outline item in relation to its parent |
|||
* |
|||
* @param aXoff is the X offset of this outline in relation to its parent |
|||
* @param aYoff is the Y offset of this outline in relation to its parent |
|||
* @param aZoff is the board offset of this outline as per IDFv3 specification |
|||
* @param aAoff is the rotational offset of this outline in relation to its parent |
|||
*/ |
|||
void GetOffsets( double& aXoff, double& aYoff, double& aZoff, double& aAngleOff ); |
|||
|
|||
/** |
|||
* Function SetParent |
|||
* sets the parent object |
|||
* |
|||
* @param aParent is the owning IDF3_COMPONENT object |
|||
*/ |
|||
void SetParent( IDF3_COMPONENT* aParent ); |
|||
|
|||
/** |
|||
* Function SetOutline |
|||
* sets the outline whose position is managed by this object |
|||
* |
|||
* @param aOutline is the outline for this component |
|||
*/ |
|||
void SetOutline( IDF3_COMP_OUTLINE* aOutline ); |
|||
|
|||
/** |
|||
* Function GetOutline |
|||
* retrieves the outline whose position is managed by this object |
|||
* |
|||
* @return IDF3_COMP_OUTLINE*: the outline for this component |
|||
*/ |
|||
IDF3_COMP_OUTLINE* GetOutline( void ) |
|||
{ |
|||
return outline; |
|||
} |
|||
|
|||
/** |
|||
* Function ReadPlaceData |
|||
* reads placement data from an open IDFv3 file |
|||
* |
|||
* @param aBoardFile is the open IDFv3 file |
|||
* @param aBoardState is the internal status flag of the IDF parser |
|||
* @param aBoard is the IDF3_BOARD object which will store the data |
|||
* |
|||
* @return bool: true if placement data was successfully read. false if |
|||
* no placement data was read; this may happen if the end of the placement |
|||
* data was encountered or an error occurred. if an error occurred then |
|||
* aBoardState is set to IDF3::FILE_INVALID or IDF3::FILE_ERROR. |
|||
*/ |
|||
bool ReadPlaceData( std::ifstream &aBoardFile, IDF3::FILE_STATE& aBoardState, |
|||
IDF3_BOARD *aBoard ); |
|||
|
|||
/** |
|||
* Function WritePlaceData |
|||
* writes RECORD 2 and RECORD 3 of a PLACEMENT section as per IDFv3 specification |
|||
* |
|||
* @param aBoardFile is the open IDFv3 file |
|||
* @param aXpos is the X location of the parent component |
|||
* @param aYpos is the Y location of the parent component |
|||
* @param aAngle is the rotation of the parent component |
|||
* @param aRefDes is the reference designator of the parent component |
|||
* @param aPlacement is the IDF Placement Status of the parent component |
|||
* @param aSide is the IDF Layer Designator (TOP or BOTTOM) |
|||
* |
|||
* @return bool: true if data was successfully written, otherwise false |
|||
*/ |
|||
bool WritePlaceData( std::ofstream& aBoardFile, double aXpos, double aYpos, double aAngle, |
|||
const std::string aRefDes, IDF3::IDF_PLACEMENT aPlacement, |
|||
IDF3::IDF_LAYER aSide ); |
|||
}; |
|||
|
|||
|
|||
class IDF3_COMPONENT |
|||
{ |
|||
private: |
|||
std::list< IDF3_COMP_OUTLINE_DATA* > components; |
|||
std::list< IDF_DRILL_DATA* > drills; |
|||
|
|||
double xpos; |
|||
double ypos; |
|||
double angle; |
|||
IDF3::IDF_PLACEMENT placement; |
|||
IDF3::IDF_LAYER layer; // [TOP/BOTTOM ONLY as per IDF spec] |
|||
bool hasPosition; ///< True after SetPosition is called once |
|||
std::string refdes; ///< Reference Description (MUST BE UNIQUE) |
|||
IDF3_BOARD* parent; |
|||
|
|||
public: |
|||
/** |
|||
* Constructor |
|||
* sets internal parameters to default values |
|||
*/ |
|||
IDF3_COMPONENT(); |
|||
|
|||
/** |
|||
* Constructor |
|||
* sets the parent object and initializes other internal parameters to default values |
|||
* |
|||
* @param aParent is the owning IDF3_BOARD object |
|||
*/ |
|||
IDF3_COMPONENT( IDF3_BOARD* aParent ); |
|||
|
|||
~IDF3_COMPONENT(); |
|||
|
|||
/** |
|||
* Function SetParent |
|||
* sets the parent object |
|||
* |
|||
* @param aParent is the owning IDF3_BOARD object |
|||
*/ |
|||
void SetParent( IDF3_BOARD* aParent ); |
|||
|
|||
/** |
|||
* Function GetCadType |
|||
* returns the type of CAD (IDF3::CAD_ELEC, IDF3::CAD_MECH) which instantiated this object |
|||
* |
|||
* @return IDF3::CAD_TYPE |
|||
*/ |
|||
IDF3::CAD_TYPE GetCadType( void ); |
|||
|
|||
/** |
|||
* Function GetCadType |
|||
* returns the IDF UNIT type of the parent object or IDF3::UNIT_INVALID if |
|||
* the parent was not set |
|||
* |
|||
* @return IDF3::IDF_UNIT |
|||
*/ |
|||
IDF3::IDF_UNIT GetUnit( void ); |
|||
|
|||
/** |
|||
* Function SetRefDes |
|||
* sets the Reference Designator (RefDes) of this component; the RefDes is shared |
|||
* by all outlines associated with this component. |
|||
* |
|||
* @return bool: true if the RefDes was accepted, otherwise false. Prohibited |
|||
* values include empty strings and the word PANEL. |
|||
*/ |
|||
bool SetRefDes( const std::string& aRefDes ); |
|||
|
|||
/** |
|||
* Function GetRefDes |
|||
* Retrieves the Reference Designator (RefDes) of this component |
|||
* |
|||
* @return string: the Reference Designator |
|||
*/ |
|||
const std::string& GetRefDes( void ); |
|||
|
|||
/** |
|||
* Function AddDrill |
|||
* adds a drill entry to the component and returns its pointer |
|||
* |
|||
* @param aDia diameter of the drill (mm) |
|||
* @param aXpos X position of the drill (mm) |
|||
* @param aYpos Y position of the drill (mm) |
|||
* @param aPlating plating type (PTH, NPTH) |
|||
* @param aHoleType hole class (PIN, VIA, MTG, TOOL, etc) |
|||
* @param aOwner owning CAD system (ECAD, MCAD, UNOWNED) |
|||
* |
|||
* @return pointer: a pointer to the newly created drill entry or NULL |
|||
*/ |
|||
IDF_DRILL_DATA* AddDrill( double aDia, double aXpos, double aYpos, |
|||
IDF3::KEY_PLATING aPlating, |
|||
const std::string aHoleType, |
|||
IDF3::KEY_OWNER aOwner ); |
|||
|
|||
/** |
|||
* Function AddDrill |
|||
* adds the given drill entry to the component and returns the pointer |
|||
* to indicate success. A return value of NULL indicates that the item |
|||
* was not added and it is the user's responsibility to delete the |
|||
* object if necessary. |
|||
* |
|||
* @param aDrilledHole pointer to a drill entry |
|||
* |
|||
* @return pointer: aDrilledHole if the function succeeds, otherwise NULL |
|||
*/ |
|||
IDF_DRILL_DATA* AddDrill( IDF_DRILL_DATA* aDrilledHole ); |
|||
|
|||
/** |
|||
* Function DelDrill( double aDia, double aXpos, double aYpos ) |
|||
* deletes a drill entry based on its size and location. This operation is |
|||
* subject to IDF ownership rules. |
|||
* |
|||
* @param aDia diameter (mm) of the drilled hole to be deleted |
|||
* @param aXpos X position (mm) of the hole to be deleted |
|||
* @param aYpos X position (mm) of the hole to be deleted |
|||
* |
|||
* @return bool: true if a drill was found and deleted, otherwise false. |
|||
* If an ownership violation occurs an exception is thrown. |
|||
*/ |
|||
bool DelDrill( double aDia, double aXpos, double aYpos ); |
|||
|
|||
/** |
|||
* Function DelDrill( IDF_DRILL_DATA* aDrill ) |
|||
* deletes a drill entry based on pointer. This operation is |
|||
* subject to IDF ownership rules. |
|||
* |
|||
* @param aDrill the pointer associated with the drill entry to be deleted |
|||
* |
|||
* @return bool: true if a drill was found and deleted, otherwise false. |
|||
* If an ownership violation occurs an exception is thrown. |
|||
*/ |
|||
bool DelDrill( IDF_DRILL_DATA* aDrill ); |
|||
|
|||
/** |
|||
* Function GetDrills |
|||
* returns a pointer to the internal list of drills. To avoid IDF |
|||
* violations, the user should not alter these entries. |
|||
*/ |
|||
const std::list< IDF_DRILL_DATA* >*const GetDrills( void ); |
|||
|
|||
/** |
|||
* Function AddOutlineData |
|||
* adds the given component outline data to this component |
|||
* |
|||
* @param aComponentOutline is a pointer to the outline data to be added |
|||
* |
|||
* @return true if the operation succeedes, otherwise false |
|||
*/ |
|||
bool AddOutlineData( IDF3_COMP_OUTLINE_DATA* aComponentOutline ); |
|||
|
|||
/** |
|||
* Function DeleteOutlineData( IDF3_COMP_OUTLINE_DATA* aComponentOutline ) |
|||
* removes outline data based on the pointer provided. |
|||
* |
|||
* @param aComponentOutline is a pointer to be deleted from the internal list |
|||
* |
|||
* @return bool: true if the data was found and deleted, otherwise false |
|||
*/ |
|||
bool DeleteOutlineData( IDF3_COMP_OUTLINE_DATA* aComponentOutline ); |
|||
|
|||
/** |
|||
* Function DeleteOutlineData( size_t aIndex ) |
|||
* removes outline data based on the provided index. |
|||
* |
|||
* @param aIndex is an index to the internal outline list |
|||
* |
|||
* @return bool: true if the data was deleted, false if the |
|||
* index was out of bounds. |
|||
*/ |
|||
bool DeleteOutlineData( size_t aIndex ); |
|||
|
|||
/** |
|||
* Function GetOutlineSize |
|||
* returns the number of outlines in the internal list |
|||
*/ |
|||
size_t GetOutlinesSize( void ); |
|||
|
|||
|
|||
/** |
|||
* Function GetOutlinesData |
|||
* returns a pointer to the internal list of outline data |
|||
*/ |
|||
const std::list< IDF3_COMP_OUTLINE_DATA* >*const GetOutlinesData( void ); |
|||
|
|||
/** |
|||
* Function GetPosition |
|||
* retrieves the internal position parameters and returns true if the |
|||
* position was previously set, otherwise false. |
|||
*/ |
|||
bool GetPosition( double& aXpos, double& aYpos, double& aAngle, IDF3::IDF_LAYER& aLayer ); |
|||
|
|||
// NOTE: it may be possible to extend this so that internal drills and outlines |
|||
// are moved when the component is moved. However there is always a danger of |
|||
// position creep due to the relative position updates. |
|||
/** |
|||
* Function SetPosition |
|||
* sets the internal position parameters and returns true if the |
|||
* position was set, false if the position was previously set. This object |
|||
* does not allow modification of the position once it is set since this may |
|||
* adversely affect the relationship with its internal objects. |
|||
* |
|||
* @param aXpos is the X position (mm) of the component |
|||
* @param aYpos is the Y position (mm) of the component |
|||
* @param aAngle is the rotation of the component (degrees) |
|||
* @param aLayer is the layer on which the component is places (TOP, BOTTOM) |
|||
* |
|||
* @return bool: true if the position was set, otherwise false |
|||
*/ |
|||
bool SetPosition( double aXpos, double aYpos, double aAngle, IDF3::IDF_LAYER aLayer ); |
|||
|
|||
/** |
|||
* Function GetPlacement |
|||
* returns the IDF placement value of this component (UNPLACED, PLACED, ECAD, MCAD) |
|||
*/ |
|||
IDF3::IDF_PLACEMENT GetPlacement( void ); |
|||
|
|||
/** |
|||
* Function SetPlacement |
|||
* sets the placement value of the component subject to ownership rules. |
|||
* An exception is thrown if aPlacementValue is invalid or an ownership |
|||
* violation occurs. |
|||
*/ |
|||
void SetPlacement( IDF3::IDF_PLACEMENT aPlacementValue ); |
|||
|
|||
/** |
|||
* Function WriteDrillData |
|||
* writes the internal drill data to an IDFv3 .DRILLED_HOLES section |
|||
* |
|||
* @param aBoardFile is an IDFv3 file opened for writing |
|||
* |
|||
* @return bool: true if the operation succeeded, otherwise false |
|||
*/ |
|||
bool WriteDrillData( std::ofstream& aBoardFile ); |
|||
|
|||
/** |
|||
* Function WritePlaceData |
|||
* writes the component placement data to an IDFv3 .PLACEMENT section |
|||
* |
|||
* @param aBoardFile is an IDFv3 file opened for writing |
|||
* |
|||
* @return bool: true if the operation succeeded, otherwise false |
|||
*/ |
|||
bool WritePlaceData( std::ofstream& aBoardFile ); |
|||
}; |
|||
|
|||
class IDF3_BOARD |
|||
{ |
|||
private: |
|||
std::list< IDF_NOTE* > notes; // IDF notes |
|||
std::list< std::string > noteComments; // comment list for NOTES section |
|||
std::list< std::string > drillComments; // comment list for DRILL section |
|||
std::list< std::string > placeComments; // comment list for PLACEMENT section |
|||
std::list<IDF_DRILL_DATA*> board_drills; |
|||
std::map< std::string, IDF3_COMPONENT*> components; // drill and placement data for components |
|||
std::map< std::string, IDF3_COMP_OUTLINE*> compOutlines; // component outlines (data for library file) |
|||
std::string boardName; |
|||
IDF3::FILE_STATE state; |
|||
IDF3::CAD_TYPE cadType; |
|||
IDF3::IDF_UNIT unit; |
|||
|
|||
std::string idfSource; // SOURCE string to use when writing BOARD and LIBRARY headers |
|||
std::string brdSource; // SOURCE string as retrieved from a BOARD file |
|||
std::string libSource; // SOURCE string as retrieved from a LIBRARY file |
|||
std::string brdDate; // DATE string from BOARD file |
|||
std::string libDate; // DATE string from LIBRARY file |
|||
int brdFileVersion; // File Version from BOARD file |
|||
int libFileVersion; // File Version from LIBRARY file |
|||
|
|||
int userPrec; // user may store any integer here |
|||
double userScale; // user may store a scale for translating to arbitrary units |
|||
double userXoff; // user may specify an arbitrary X/Y offset |
|||
double userYoff; |
|||
|
|||
// main board outline and cutouts |
|||
BOARD_OUTLINE olnBoard; |
|||
// OTHER outlines |
|||
std::map<std::string, OTHER_OUTLINE*> olnOther; |
|||
// ROUTE outlines |
|||
std::list<ROUTE_OUTLINE*> olnRoute; |
|||
// PLACEMENT outlines |
|||
std::list<PLACE_OUTLINE*> olnPlace; |
|||
// ROUTE KEEPOUT outlines |
|||
std::list<ROUTE_KO_OUTLINE*> olnRouteKeepout; |
|||
// VIA KEEPOUT outlines |
|||
std::list<VIA_KO_OUTLINE*> olnViaKeepout; |
|||
// PLACE KEEPOUT outlines |
|||
std::list<PLACE_KO_OUTLINE*> olnPlaceKeepout; |
|||
// PLACEMENT GROUP outlines |
|||
std::multimap<std::string, GROUP_OUTLINE*> olnGroup; |
|||
|
|||
// Set the unit; this can only be done internally upon |
|||
// reading a file or saving |
|||
bool setUnit( IDF3::IDF_UNIT aUnit, bool convert = false ); |
|||
|
|||
IDF_DRILL_DATA* addCompDrill( double aDia, double aXpos, double aYpos, |
|||
IDF3::KEY_PLATING aPlating, |
|||
const std::string aHoleType, |
|||
IDF3::KEY_OWNER aOwner, |
|||
const std::string& aRefDes ); |
|||
|
|||
IDF_DRILL_DATA* addCompDrill( IDF_DRILL_DATA* aDrilledHole ); |
|||
|
|||
bool delCompDrill( double aDia, double aXpos, double aYpos, std::string aRefDes ); |
|||
|
|||
// read the DRILLED HOLES section |
|||
bool readBrdDrills( std::ifstream& aBoardFile, IDF3::FILE_STATE& aBoardState ); |
|||
// read the NOTES section |
|||
bool readBrdNotes( std::ifstream& aBoardFile, IDF3::FILE_STATE& aBoardState ); |
|||
// read the component placement section |
|||
bool readBrdPlacement( std::ifstream& aBoardFile, IDF3::FILE_STATE& aBoardState ); |
|||
// read the board HEADER |
|||
bool readBrdHeader( std::ifstream& aBoardFile, IDF3::FILE_STATE& aBoardState ); |
|||
// read individual board sections; pay attention to IDFv3 section specifications |
|||
bool readBrdSection( std::ifstream& aBoardFile, IDF3::FILE_STATE& aBoardState ); |
|||
// read the board file data |
|||
bool readBoardFile( const std::string& aFileName ); |
|||
|
|||
// write the board file data |
|||
bool writeBoardFile( const std::string& aFileName ); |
|||
|
|||
// read the library sections (outlines) |
|||
bool readLibSection( std::ifstream& aLibFile, IDF3::FILE_STATE& aLibState, IDF3_BOARD* aBoard ); |
|||
// read the library HEADER |
|||
bool readLibHeader( std::ifstream& aLibFile, IDF3::FILE_STATE& aLibState ); |
|||
// read the library file data |
|||
bool readLibFile( const std::string& aFileName ); |
|||
|
|||
// write the library file data |
|||
bool writeLibFile( const std::string& aFileName ); |
|||
|
|||
public: |
|||
IDF3_BOARD( IDF3::CAD_TYPE aCadType ); |
|||
virtual ~IDF3_BOARD(); |
|||
|
|||
IDF3::CAD_TYPE GetCadType( void ); |
|||
|
|||
// retrieve the nominal unit used in reading/writing |
|||
// data. This is primarily for use by owned objects |
|||
// and is only of informational use for the end user. |
|||
// Internally all data is represented in mm and the |
|||
// end user must use only mm in the API. |
|||
IDF3::IDF_UNIT GetUnit( void ); |
|||
|
|||
void SetBoardName( std::string aBoardName ); |
|||
const std::string& GetBoardName( void ); |
|||
|
|||
bool SetBoardThickness( double aBoardThickness ); |
|||
double GetBoardThickness( void ); |
|||
|
|||
bool ReadFile( const wxString& aFullFileName ); |
|||
bool WriteFile( const wxString& aFullFileName, bool aUnitMM = true, bool aForceUnitFlag = false ); |
|||
|
|||
const std::string& GetIDFSource( void ); |
|||
void SetIDFSource( const std::string& aIDFSource); |
|||
const std::string& GetBoardSource( void ); |
|||
const std::string& GetLibrarySource( void ); |
|||
const std::string& GetBoardDate( void ); |
|||
const std::string& GetLibraryDate( void ); |
|||
int GetBoardVersion( void ); |
|||
bool SetBoardVersion( int aVersion ); |
|||
int GetLibraryVersion( void ); |
|||
bool SetLibraryVersion( int aVersion ); |
|||
|
|||
double GetUserScale( void ); |
|||
bool SetUserScale( double aScaleFactor ); |
|||
|
|||
int GetUserPrecision( void ); |
|||
bool SetUserPrecision( int aPrecision ); |
|||
|
|||
void GetUserOffset( double& aXoff, double& aYoff ); |
|||
void SetUserOffset( double aXoff, double aYoff ); |
|||
|
|||
bool AddBoardOutline( IDF_OUTLINE* aOutline ); |
|||
bool DelBoardOutline( IDF_OUTLINE* aOutline ); |
|||
bool DelBoardOutline( size_t aIndex ); |
|||
size_t GetBoardOutlinesSize( void ); |
|||
BOARD_OUTLINE* GetBoardOutline( void ); |
|||
const std::list< IDF_OUTLINE* >*const GetBoardOutlines( void ); |
|||
|
|||
/// XXX - TO BE IMPLEMENTED |
|||
// AddDrillComment |
|||
// AddPlacementComment |
|||
// GetDrillComments() |
|||
// GetPlacementComments() |
|||
// ClearDrillComments() |
|||
// ClearPlacementComments() |
|||
// AddNoteComment |
|||
// GetNoteComments |
|||
// AddNote |
|||
// |
|||
// const std::map<std::string, OTHER_OUTLINE*>*const GetOtherOutlines() |
|||
// size_t GetOtherOutlinesSize() |
|||
// OTHER_OUTLINE* AddOtherOutline( OTHER_OUTLINE* aOtherOutline ) |
|||
// bool DelOtherOutline( int aIndex ) |
|||
// bool DelOtherOutline( OTHER_OUTLINE* aOtherOutline ) |
|||
// |
|||
// const std::list<ROUTE_OUTLINE*>*const GetRouteOutlines() |
|||
// size_t GetRouteOutlinesSize() |
|||
// ROUTE_OUTLINE* AddRouteOutline( ROUTE_OUTLINE* aRouteOutline ) |
|||
// bool DelRouteOutline( int aIndex ) |
|||
// bool DelRouteOutline( ROUTE_OUTLINE* aRouteOutline ) |
|||
// |
|||
// const std::list<PLACE_OUTLINE*>*const GetPlacementOutlines() |
|||
// size_t GetPlacementOutlinesSize() |
|||
// PLACE_OUTLINE* AddPlacementOutline( PLACE_OUTLINE* aPlaceOutline ) |
|||
// bool DelPlacementOutline( int aIndex ) |
|||
// bool DelPlacementOutline( PLACE_OUTLINE* aPlaceOutline ) |
|||
// |
|||
// const std::list<ROUTE_KO_OUTLINE*>*const GetRouteKeepOutOutlines() |
|||
// size_t GetRouteKeepOutOutlinesSize() |
|||
// ROUTE_KO_OUTLINE* AddRouteKeepoutOutline( ROUTE_KO_OUTLINE* aRouteKeepOut ) |
|||
// bool DelRouteKeepOutOutline( int aIndex ) |
|||
// bool DelRouteKeepOutOutline( ROUTE_KO_OUTLINE* aRouteKeepOut ) |
|||
// |
|||
// const std::list<VIA_KO_OUTLINE*>*const GetViaKeepOutOutlines() |
|||
// size_t GetViaKeepOutOutlinesSize() |
|||
// VIA_KO_OUTLINE* AddViaKeepoutOutline( VIA_KO_OUTLINE* aViaKeepOut ) |
|||
// bool DelViaKeepOutOutline( int aIndex ) |
|||
// bool DelViaKeepOutOutline( VIA_KO_OUTLINE* aViaKeepOut ) |
|||
// |
|||
// const std::list<PLACE_KO_OUTLINE*>*const GetPlacementKeepOutOutlines() |
|||
// size_t GetPlacementKeepOutOutlinesSize() |
|||
// PLACE_KO_OUTLINE* AddPlacementKeepoutOutline( PLACE_KO_OUTLINE* aPlaceKeepOut ) |
|||
// bool DelPlacementKeepOutOutline( int aIndex ) |
|||
// bool DelPlacementKeepOutOutline( PLACE_KO_OUTLINE* aPlaceKeepOut ) |
|||
// |
|||
// const std::multimap<std::string, GROUP_OUTLINE*>*const GetGroupOutlines() |
|||
// size_t GetGroupOutlinesSize() |
|||
// GROUP_OUTLINE* AddGroupOutline( GROUP_OUTLINE* aGroupOutline ) |
|||
// bool DelGroupOutline( int aIndex ) |
|||
// bool DelGroupOutline( GROUP_OUTLINE* aGroupOutline ) |
|||
|
|||
std::list<IDF_DRILL_DATA*>& GetBoardDrills( void ) |
|||
{ |
|||
return board_drills; |
|||
} |
|||
|
|||
IDF_DRILL_DATA* AddBoardDrill( double aDia, double aXpos, double aYpos, |
|||
IDF3::KEY_PLATING aPlating, |
|||
const std::string aHoleType, |
|||
IDF3::KEY_OWNER aOwner ); |
|||
|
|||
IDF_DRILL_DATA* AddDrill( IDF_DRILL_DATA* aDrilledHole ); |
|||
|
|||
bool DelBoardDrill( double aDia, double aXpos, double aYpos ); |
|||
|
|||
// a slot is a deficient representation of a kicad slotted hole; |
|||
// it is usually associated with a component but IDFv3 does not |
|||
// provide for such an association. |
|||
bool AddSlot( double aWidth, double aLength, double aOrientation, double aX, double aY ); |
|||
|
|||
bool AddComponent( IDF3_COMPONENT* aComponent ); |
|||
bool DelComponent( IDF3_COMPONENT* aComponent ); |
|||
bool DelComponent( size_t aIndex ); |
|||
size_t GetComponentsSize( void ); |
|||
std::map< std::string, IDF3_COMPONENT* >*const GetComponents( void ); |
|||
IDF3_COMPONENT* FindComponent( std::string aRefDes ); |
|||
|
|||
// returns a pointer to a component outline object or NULL |
|||
// if the object doesn't exist |
|||
IDF3_COMP_OUTLINE* GetComponentOutline( const std::string aGeomName, |
|||
const std::string aPartName, |
|||
wxString aFullFileName ); |
|||
|
|||
// returns a pointer to the component outline object with the |
|||
// unique ID aComponentID |
|||
IDF3_COMP_OUTLINE* GetComponentOutline( std::string aComponentID ); |
|||
|
|||
// returns a pointer to the outline "NOGEOM NOPART" which is substituted |
|||
// whenever a true outline cannot be found or is defective |
|||
IDF3_COMP_OUTLINE* GetInvalidOutline( const std::string& aGeomName, const std::string& aPartName ); |
|||
|
|||
// clears all data |
|||
void Clear( void ); |
|||
}; |
|||
|
|||
#endif // IDF_PARSER_H |
|||
1578
utils/idftools/vrml_layer.cpp
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,429 @@ |
|||
/* |
|||
* file: vrml_layer.h |
|||
* |
|||
* This program source code file is part of KiCad, a free EDA CAD application. |
|||
* |
|||
* Copyright (C) 2013 Cirilo Bernardo |
|||
* |
|||
* This program is free software; you can redistribute it and/or |
|||
* modify it under the terms of the GNU General Public License |
|||
* as published by the Free Software Foundation; either version 2 |
|||
* of the License, or (at your option) any later version. |
|||
* |
|||
* This program is distributed in the hope that it will be useful, |
|||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
* GNU General Public License for more details. |
|||
* |
|||
* You should have received a copy of the GNU General Public License |
|||
* along with this program; if not, you may find one here: |
|||
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html |
|||
* or you may search the http://www.gnu.org website for the version 2 license, |
|||
* or you may write to the Free Software Foundation, Inc., |
|||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA |
|||
*/ |
|||
|
|||
/** |
|||
* @file vrml_layer.h |
|||
*/ |
|||
|
|||
/* |
|||
* Classes and structures to support the tesselation of a |
|||
* PCB for VRML output. |
|||
*/ |
|||
|
|||
#ifndef VRML_BOARD_H |
|||
#define VRML_BOARD_H |
|||
|
|||
#ifdef __WXMAC__ |
|||
# ifdef __DARWIN__ |
|||
# include <OpenGL/glu.h> |
|||
# else |
|||
# include <glu.h> |
|||
# endif |
|||
#else |
|||
# include <GL/glu.h> |
|||
#endif |
|||
|
|||
#include <fstream> |
|||
#include <vector> |
|||
#include <list> |
|||
#include <utility> |
|||
|
|||
#ifndef M_PI2 |
|||
#define M_PI2 ( M_PI / 2.0 ) |
|||
#endif |
|||
|
|||
#ifndef M_PI4 |
|||
#define M_PI4 ( M_PI / 4.0 ) |
|||
#endif |
|||
|
|||
struct GLUtesselator; |
|||
|
|||
struct VERTEX_3D |
|||
{ |
|||
double x; |
|||
double y; |
|||
int i; // vertex index |
|||
int o; // vertex order |
|||
}; |
|||
|
|||
struct TRIPLET_3D |
|||
{ |
|||
int i1, i2, i3; |
|||
|
|||
TRIPLET_3D( int p1, int p2, int p3 ) |
|||
{ |
|||
i1 = p1; |
|||
i2 = p2; |
|||
i3 = p3; |
|||
} |
|||
}; |
|||
|
|||
|
|||
class VRML_LAYER |
|||
{ |
|||
private: |
|||
// Arc parameters |
|||
int maxArcSeg; // maximum number of arc segments in a small circle |
|||
double minSegLength; // min. segment length |
|||
double maxSegLength; // max. segment length |
|||
|
|||
bool fix; // when true, no more vertices may be added by the user |
|||
int idx; // vertex index (number of contained vertices) |
|||
int ord; // vertex order (number of ordered vertices) |
|||
std::vector<VERTEX_3D*> vertices; // vertices of all contours |
|||
std::vector<std::list<int>*> contours; // lists of vertices for each contour |
|||
std::vector< double > areas; // area of the contours (positive if winding is CCW) |
|||
std::list<TRIPLET_3D> triplets; // output facet triplet list (triplet of ORDER values) |
|||
std::list<std::list<int>*> outline; // indices for outline outputs (index by ORDER values) |
|||
std::vector<int> ordmap; // mapping of ORDER to INDEX |
|||
|
|||
std::string error; // error message |
|||
|
|||
int hidx; // number of vertices in the holes |
|||
int eidx; // index for extra vertices |
|||
std::vector<VERTEX_3D*> extra_verts; // extra vertices added for outlines and facets |
|||
std::vector<VERTEX_3D*> vlist; // vertex list for the GL command in progress |
|||
VRML_LAYER* pholes; // pointer to another layer object used for tesselation; |
|||
// this object is normally expected to hold only holes |
|||
|
|||
GLUtesselator* tess; // local instance of the GLU tesselator |
|||
|
|||
GLenum glcmd; // current GL command type ( fan, triangle, tri-strip, loop ) |
|||
|
|||
void clearTmp( void ); // clear ephemeral data used by the tesselation routine |
|||
|
|||
// add a triangular facet (triplet) to the output index list |
|||
bool addTriplet( VERTEX_3D* p0, VERTEX_3D* p1, VERTEX_3D* p2 ); |
|||
|
|||
// retrieve a vertex given its index; the vertex may be contained in the |
|||
// vertices vector, extra_verts vector, or foreign VRML_LAYER object |
|||
VERTEX_3D* getVertexByIndex( int aPointIndex, VRML_LAYER* holes ); |
|||
|
|||
void processFan( void ); // process a GL_TRIANGLE_FAN list |
|||
void processStrip( void ); // process a GL_TRIANGLE_STRIP list |
|||
void processTri( void ); // process a GL_TRIANGLES list |
|||
|
|||
void pushVertices( bool holes ); // push the internal vertices |
|||
bool pushOutline( VRML_LAYER* holes ); // push the outline vertices |
|||
|
|||
// calculate number of sides on an arc (angle is in radians) |
|||
int calcNSides( double aRadius, double aAngle ); |
|||
|
|||
public: |
|||
/// set to true when a fault is encountered during tesselation |
|||
bool Fault; |
|||
|
|||
VRML_LAYER(); |
|||
virtual ~VRML_LAYER(); |
|||
|
|||
/** |
|||
* Function GetArcParams |
|||
* retieves the parameters used in calculating the number of vertices in an arc |
|||
* |
|||
* @param aMaxSeg is the maximum number of segments for an arc with cords of length aMinLength |
|||
* @param aMinLength is the minimum length of cords in an arc |
|||
* @param aMaxLength is the maximum length of cords in an arc |
|||
*/ |
|||
void GetArcParams( int& aMaxSeg, double& aMinLength, double& aMaxLength ); |
|||
|
|||
/** |
|||
* Function SetArcParams |
|||
* sets the parameters used in calculating the number of vertices in an arc. |
|||
* The default settings are reasonable for rendering for unit lengths of 1mm |
|||
* |
|||
* @param aMaxSeg is the maximum number of segments for an arc with cords of length aMinLength |
|||
* @param aMinLength is the minimum length of cords in an arc |
|||
* @param aMaxLength is the maximum length of cords in an arc |
|||
* |
|||
* @return bool: true if the parameters were accepted |
|||
*/ |
|||
bool SetArcParams( int aMaxSeg, double aMinLength, double aMaxLength ); |
|||
|
|||
/** |
|||
* Function Clear |
|||
* erases all data except for arc parameters. |
|||
*/ |
|||
void Clear( void ); |
|||
|
|||
/** |
|||
* Function GetSize |
|||
* returns the total number of vertices indexed |
|||
*/ |
|||
int GetSize( void ); |
|||
|
|||
/** |
|||
* Function GetNConours |
|||
* returns the number of stored contours |
|||
*/ |
|||
int GetNContours( void ) |
|||
{ |
|||
return contours.size(); |
|||
} |
|||
|
|||
/** |
|||
* Function NewContour |
|||
* creates a new list of vertices and returns an index to the list |
|||
* |
|||
* @return int: index to the list or -1 if the operation failed |
|||
*/ |
|||
int NewContour( void ); |
|||
|
|||
/** |
|||
* Function AddVertex |
|||
* adds a point to the requested contour |
|||
* |
|||
* @param aContour is an index previously returned by a call to NewContour() |
|||
* @param aXpos is the X coordinate of the vertex |
|||
* @param aYpos is the Y coordinate of the vertex |
|||
* |
|||
* @return bool: true if the vertex was added |
|||
*/ |
|||
bool AddVertex( int aContourID, double aXpos, double aYpos ); |
|||
|
|||
/** |
|||
* Function EnsureWinding |
|||
* checks the winding of a contour and ensures that it is a hole or |
|||
* a solid depending on the value of @param hole |
|||
* |
|||
* @param aContour is an index to a contour as returned by NewContour() |
|||
* @param aHoleFlag determines if the contour must be a hole |
|||
* |
|||
* @return bool: true if the operation suceeded |
|||
*/ |
|||
bool EnsureWinding( int aContourID, bool aHoleFlag ); |
|||
|
|||
/** |
|||
* Function AppendCircle |
|||
* adds a circular contour to the specified (empty) contour |
|||
* |
|||
* @param aXpos is the X coordinate of the hole center |
|||
* @param aYpos is the Y coordinate of the hole center |
|||
* @param aRadius is the radius of the hole |
|||
* @param aContourID is the contour index |
|||
* @param aHoleFlag determines if the contour to be created is a cutout |
|||
* |
|||
* @return bool: true if the new contour was successfully created |
|||
*/ |
|||
bool AppendCircle( double aXpos, double aYpos, double aRadius, int aContourID, bool aHoleFlag = false ); |
|||
|
|||
/** |
|||
* Function AddCircle |
|||
* creates a circular contour and adds it to the internal list |
|||
* |
|||
* @param aXpos is the X coordinate of the hole center |
|||
* @param aYpos is the Y coordinate of the hole center |
|||
* @param aRadius is the radius of the hole |
|||
* @param aHoleFlag determines if the contour to be created is a cutout |
|||
* |
|||
* @return bool: true if the new contour was successfully created |
|||
*/ |
|||
bool AddCircle( double aXpos, double aYpos, double aRadius, bool aHoleFlag = false ); |
|||
|
|||
/** |
|||
* Function AddSlot |
|||
* creates and adds a slot feature to the list of contours |
|||
* |
|||
* @param aCenterX is the X coordinate of the slot's center |
|||
* @param aCenterY is the Y coordinate of the slot's center |
|||
* @param aSlotLength is the length of the slot along the major axis |
|||
* @param aSlotWidth is the width of the slot along the minor axis |
|||
* @param aAngle (degrees) is the orientation of the slot |
|||
* @param aHoleFlag determines whether the slot is a hole or a solid |
|||
* |
|||
* @return bool: true if the slot was successfully created |
|||
*/ |
|||
bool AddSlot( double aCenterX, double aCenterY, double aSlotLength, double aSlotWidth, |
|||
double aAngle, bool aHoleFlag = false ); |
|||
|
|||
/** |
|||
* Function AppendArc |
|||
* adds an arc to the specified contour |
|||
* |
|||
* @param aCenterX is the X coordinate of the arc's center |
|||
* @param aCenterY is the Y coordinate of the arc's center |
|||
* @param aRadius is the radius of the arc |
|||
* @param aStartAngle (degrees) is the starting angle of the arc |
|||
* @param aAngle (degrees) is the measure of the arc |
|||
* @param aContourID is the contour's index |
|||
* |
|||
* @return bool: true if the slot was successfully created |
|||
*/ |
|||
bool AppendArc( double aCenterX, double aCenterY, double aRadius, |
|||
double aStartAngle, double aAngle, int aContourID ); |
|||
|
|||
/** |
|||
* Function AddArc |
|||
* creates a slotted arc and adds it to the internal list of contours |
|||
* |
|||
* @param aCenterX is the X coordinate of the arc's center |
|||
* @param aCenterY is the Y coordinate of the arc's center |
|||
* @param aStartX is the X coordinate of the starting point |
|||
* @param aStartY is the Y coordinate of the starting point |
|||
* @param aArcWidth is the width of the arc |
|||
* @param aAngle is the included angle (degrees) |
|||
* @param aHoleFlag determines whether the arc is to be a hole or a solid |
|||
* |
|||
* @return bool: true if the feature was successfully created |
|||
*/ |
|||
bool AddArc( double aCenterX, double aCenterY, double aStartX, double aStartY, |
|||
double aArcWidth, double aAngle, bool aHoleFlag = false ); |
|||
|
|||
/** |
|||
* Function Tesselate |
|||
* creates a list of outline vertices as well as the |
|||
* vertex sets required to render the surface. |
|||
* |
|||
* @param holes is an optional pointer to cutouts to be imposed on the |
|||
* surface. |
|||
* |
|||
* @return bool: true if the operation succeeded |
|||
*/ |
|||
bool Tesselate( VRML_LAYER* holes = NULL ); |
|||
|
|||
/** |
|||
* Function WriteVertices |
|||
* writes out the list of vertices required to render a |
|||
* planar surface. |
|||
* |
|||
* @param aZcoord is the Z coordinate of the plane |
|||
* @param aOutFile is the file to write to |
|||
* @param aPrecision is the precision of the output coordinates |
|||
* |
|||
* @return bool: true if the operation succeeded |
|||
*/ |
|||
bool WriteVertices( double aZcoord, std::ofstream& aOutFile, int aPrecision ); |
|||
|
|||
/** |
|||
* Function Write3DVertices |
|||
* writes out the list of vertices required to render an extruded solid |
|||
* |
|||
* @param aTopZ is the Z coordinate of the top plane |
|||
* @param aBottomZ is the Z coordinate of the bottom plane |
|||
* @param aOutFile is the file to write to |
|||
* @param aPrecision is the precision of the output coordinates |
|||
* |
|||
* @return bool: true if the operation succeeded |
|||
*/ |
|||
bool Write3DVertices( double aTopZ, double aBottomZ, std::ofstream& aOutFile, int aPrecision ); |
|||
|
|||
/** |
|||
* Function WriteIndices |
|||
* writes out the vertex sets required to render a planar |
|||
* surface. |
|||
* |
|||
* @param aTopFlag is true if the surface is to be visible from above; |
|||
* if false the surface will be visible from below. |
|||
* @param aOutFile is the file to write to |
|||
* |
|||
* @return bool: true if the operation succeeded |
|||
*/ |
|||
bool WriteIndices( bool aTopFlag, std::ofstream& aOutFile ); |
|||
|
|||
/** |
|||
* Function Write3DIndices |
|||
* writes out the vertex sets required to render an extruded solid |
|||
* |
|||
* @param aOutFile is the file to write to |
|||
* |
|||
* @return bool: true if the operation succeeded |
|||
*/ |
|||
bool Write3DIndices( std::ofstream& aOutFile ); |
|||
|
|||
/** |
|||
* Function AddExtraVertex |
|||
* adds an extra vertex as required by the GLU tesselator |
|||
* |
|||
* @return VERTEX_3D*: is the new vertex or NULL if a vertex |
|||
* could not be created. |
|||
*/ |
|||
VERTEX_3D* AddExtraVertex( double aXpos, double aYpos ); |
|||
|
|||
/** |
|||
* Function glStart |
|||
* is invoked by the GLU tesselator callback to notify this object |
|||
* of the type of GL command which is applicable to the upcoming |
|||
* vertex list. |
|||
* |
|||
* @param cmd is the GL command |
|||
*/ |
|||
void glStart( GLenum cmd ); |
|||
|
|||
/** |
|||
* Function glPushVertex |
|||
* is invoked by the GLU tesselator callback; the supplied vertex is |
|||
* added to the internal list of vertices awaiting processing upon |
|||
* execution of glEnd() |
|||
* |
|||
* @param vertex is a vertex forming part of the GL command as previously |
|||
* set by glStart |
|||
*/ |
|||
void glPushVertex( VERTEX_3D* vertex ); |
|||
|
|||
/** |
|||
* Function glEnd |
|||
* is invoked by the GLU tesselator callback to notify this object |
|||
* that the vertex list is complete and ready for processing |
|||
*/ |
|||
void glEnd( void ); |
|||
|
|||
/** |
|||
* Function SetGLError |
|||
* sets the error message according to the specified OpenGL error |
|||
*/ |
|||
void SetGLError( GLenum error_id ); |
|||
|
|||
/** |
|||
* Function Import |
|||
* inserts all contours into the given tesselator; this |
|||
* results in the renumbering of all vertices from @param start. |
|||
* Take care when using this call since tesselators cannot work on |
|||
* the internal data concurrently. |
|||
* |
|||
* @param start is the starting number for vertex indices |
|||
* @param tess is a pointer to a GLU Tesselator object |
|||
* |
|||
* @return int: the number of vertices exported |
|||
*/ |
|||
int Import( int start, GLUtesselator* tess ); |
|||
|
|||
/** |
|||
* Function GetVertexByIndex |
|||
* returns a pointer to the requested vertex or |
|||
* NULL if no such vertex exists. |
|||
* |
|||
* @param aPointIndex is a vertex index |
|||
* |
|||
* @return VERTEX_3D*: the requested vertex or NULL |
|||
*/ |
|||
VERTEX_3D* GetVertexByIndex( int aPointIndex ); |
|||
|
|||
/* |
|||
* Function GetError |
|||
* Returns the error message related to the last failed operation |
|||
*/ |
|||
const std::string& GetError( void ); |
|||
}; |
|||
|
|||
#endif // VRML_BOARD_H |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue