libetherpix

1) /*

2)  * EtherPix config file generator

3)  *

4)  * Copyright 2010-2017 Stefan Schuermans <stefan schuermans info>

5)  *
6)  * This program is free software: you can redistribute it and/or modify
7)  * it under the terms of the GNU General Public License as published by
8)  * the Free Software Foundation, version 3 of the License.
9)  *
10)  *
11)  * This program is distributed in the hope that it will be useful,
12)  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13)  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14)  * GNU General Public License for more details.
15)  *
16)  * You should have received a copy of the GNU Lesser General Public License
17)  * along with this program. If not, see <http://www.gnu.org/licenses/>.
18)  */
19) 
20) #include <algorithm>
21) #include <dime/entities/Entity.h>
22) #include <dime/Input.h>
23) #include <dime/Model.h>
24) #include <dime/State.h>
25) #include <fstream>
26) #include <iostream>
27) #include <map>
28) #include <string>
29) 
30) #include "chain.h"
31) #include "constants.h"
32) #include "distri.h"
33) #include "layer.h"
34) #include "line.h"
35) #include "pixel.h"
36) #include "point.h"
37) 

38) #define SUCCESS (0) // no error
39) #define ERR_USAGE (2) // invalid command line arguments
40) #define ERR_FILE_OPEN (3) // could not open input/output file
41) #define ERR_FILE_READ (4) // could not read input file
42) #define ERR_FILE_PROC (5) // could not process input file
43) #define ERR_PROC (5) // error in processing of objects found in input file
44) 

45) // layers of drawing

46) Layer gLayerVideo, gLayerPixel, gLayerNetwork;
47) std::map<unsigned int, Layer> gLayerCables, gLayerDistributors;
48) Layer gLayerCable;
49) 

50) /**
51)  * @brief get configuration from special layer names
52)  * @param[in] model DXF drawing
53)  * @param[out] width virtual frame width in pixels
54)  * @param[out] height virtual frame height in pixels
55)  * @param[out] chains number of outputs / pixel chains per distributor
56)  * @param[out] pixels number of pixels per chain
57)  * return true for success
58)  */
59) static bool get_config(dimeModel const &model,
60)                        unsigned int &width, unsigned int &height,
61)                        unsigned int &chains, unsigned int &pixels)
62) {
63)   int layers, layer_no;
64) 
65)   width = 0;
66)   height = 0;
67)   chains = 0;
68)   pixels = 0;
69) 
70)   layers = model.getNumLayers();
71)   for (layer_no = 0; layer_no < layers; ++layer_no) {
72)     dimeLayer const *layer = model.getLayer(layer_no);
73)     std::string strLayerName = layer->getLayerName();
74) 
75)     if (strLayerName.substr(0, 10) == "cfg_width ") {
76)       if (width != 0) {
77)         std::cerr << "duplicate configuration of width" << std::endl;
78)         return false;
79)       }
80)       width = strtoul(strLayerName.substr(10).c_str(), NULL, 0);
81)       if (width == 0) {
82)         std::cerr << "invalid configuration of width" << std::endl;
83)         return false;
84)       }
85)     } else if (strLayerName.substr(0, 11) == "cfg_height ") {
86)       if (height != 0) {
87)         std::cerr << "duplicate configuration of height" << std::endl;
88)         return false;
89)       }
90)       height = strtoul(strLayerName.substr(11).c_str(), NULL, 0);
91)       if (height == 0) {
92)         std::cerr << "invalid configuration of height" << std::endl;
93)         return false;
94)       }
95)     } else if (strLayerName.substr(0, 12) == "cfg_outputs ") {
96)       if (chains != 0) {
97)         std::cerr << "duplicate configuration of number of outputs per distributor"
98)                   << std::endl;
99)         return false;
100)       }
101)       chains = strtoul(strLayerName.substr(12).c_str(), NULL, 0);
102)       if (chains == 0) {
103)         std::cerr << "invalid configuration of number of outputs per distributor"
104)                   << std::endl;
105)         return false;
106)       }
107)     } else if (strLayerName.substr(0, 11) == "cfg_pixels ") {
108)       if (pixels != 0) {
109)         std::cerr << "duplicate configuration of number of pixels per output"
110)                   << std::endl;
111)         return false;
112)       }
113)       pixels = strtoul(strLayerName.substr(11).c_str(), NULL, 0);
114)       if (pixels == 0) {
115)         std::cerr << "invalid configuration of number of pixels per output"
116)                   << std::endl;
117)         return false;
118)       }
119)     }
120) 
121)   } // for layer_no
122) 
123)   if (width == 0) {
124)     std::cerr << "missing configuration of width" << std::endl;
125)     return false;
126)   }
127)   if (height == 0) {
128)     std::cerr << "missing configuration of height" << std::endl;
129)     return false;
130)   }
131)   if (chains == 0) {
132)     std::cerr << "missing configuration of number of outputs per distributor"
133)               << std::endl;
134)     return false;
135)   }
136)   if (pixels == 0) {
137)     std::cerr << "missing configuration of number of pixels per output"
138)               << std::endl;
139)     return false;
140)   }
141) 
142)   std::cout << "configuration:" << std::endl;
143)   std::cout << "  width: " << width << std::endl;
144)   std::cout << "  height: " << height << std::endl;
145)   std::cout << "  outputs: " << chains << std::endl;
146)   std::cout << "  pixels: " << pixels << std::endl;
147) 
148)   return true;
149) }
150) 

151) /**

152)  * @brief enumerate a entity in the DXF file

153)  * @param[in] state current state of libdime
154)  * @param[in] entity pointer to entity
155)  * @param[in] vp_ctx context pointer
156)  * @return if to continue enumeration
157)  */

158) static bool cbEntity(const class dimeState * const state,
159)                      class dimeEntity *entity, void *vp_ctx)

160) {
161)   (void)vp_ctx;
162) 
163)   // get layer
164)   std::string strLayerName = entity->getLayerName();
165)   Layer * pLayer;

166)   if (strLayerName == "video") {

167)     pLayer = &gLayerVideo;

168)   } else if (strLayerName == "pixel") {

169)     pLayer = &gLayerPixel;

170)   } else if (strLayerName == "network") {

171)     pLayer = &gLayerNetwork;

172)   } else if (strLayerName == "cable") {
173)     pLayer = &gLayerCables[0];
174)   } else if (strLayerName.substr(0, 6) == "cable ") {
175)     unsigned int no = strtoul(strLayerName.substr(6).c_str(), NULL, 0);

176)     pLayer = &gLayerCables[no];
177)   } else if (strLayerName.substr(0, 12) == "distributor ") {

178)     unsigned int no = strtoul(strLayerName.substr(12).c_str(), NULL, 0);

179)     pLayer = &gLayerDistributors[no];

180)   } else {

181)     return true; // unknown layer -> ignore

182)   }

183) 
184)   // get transformation matrix
185)   dimeMatrix matrix;
186)   state->getMatrix(matrix);
187) 
188)   // get geometry data
189)   dimeArray<dimeVec3f> vertices;
190)   dimeArray<int> indices;
191)   dimeVec3f extrusionDir;
192)   dxfdouble thickness;
193)   entity->extractGeometry(vertices, indices, extrusionDir, thickness);
194) 
195)   // transform geometry data
196)   for (int i = 0; i < vertices.count(); ++i)
197)     matrix.multMatrixVec(vertices[i]);
198) 
199)   // build object from geometry data
200)   Object *pObject = new Object;
201)   for (int i = 1; i < vertices.count(); ++i) {
202)     Line *pLine = new Line(Point(vertices[i - 1].x, vertices[i - 1].y),
203)                            Point(vertices[i].x, vertices[i].y));
204)     if (pLine->length() >= EPSILON) // ignore dots
205)       pObject->add(pLine);
206)     else {

207)       std::cerr << "ignoring dot at " << pLine->mStart.mX << ","

208)                 << pLine->mStart.mY << std::endl;
209)       delete pLine;
210)     }
211)   }
212) 
213)   // build object into layer
214)   pLayer->build(pObject);
215) 
216)   return true;
217) }
218) 

219) /**
220)  * @brief read a DXF file and process objects found in it
221)  * @param[in] strDxfFileName name of DXF file
222)  * @param[out] width width of logical video frame
223)  * @param[out] height height of logical video frame
224)  * @param[out] chains number of chains (outputs) per distributor
225)  * @param[out] pixels number of pixels in one chain
226)  *                                    (i.e. connected to one output)
227)  * @return SUCCESS on success, other value on error
228)  */
229) static int readDXF(std::string const &strDxfFileName,
230)                    unsigned int &width, unsigned int &height,
231)                    unsigned int &chains, unsigned int &pixels)
232) {
233)   // read DXF file
234)   dimeInput in;
235)   if (!in.setFile(strDxfFileName.c_str())) {
236)     std::cerr << "error opening file \"" << strDxfFileName
237)               << "\" for reading" << std::endl;
238)     return ERR_FILE_OPEN;
239)   }
240)   dimeModel model;
241)   if (!model.read(&in)) {
242)     std::cerr << "DXF read error in line " << in.getFilePosition()
243)               << " of file \"" << strDxfFileName << "\""
244)               << std::endl;
245)     return ERR_FILE_READ;
246)   }
247) 
248)   // get configuration from layers
249)   if (! get_config(model, width, height, chains, pixels)) {
250)     return ERR_FILE_PROC;
251)   }
252) 
253)   // enumerate all entities
254)   model.traverseEntities(cbEntity, NULL);
255) 
256)   // merge all cable layers
257)   std::map<unsigned int, Layer>::iterator itCable;
258)   for (itCable = gLayerCables.begin();
259)        itCable != gLayerCables.end(); ++itCable)
260)   gLayerCable.merge(&itCable->second);
261)   // gLayerCables[] is now empty and will not be used any more
262) 
263)   // output object count information
264)   std::cout << "object counts:" << std::endl;
265)   std::cout << "  video: " << gLayerVideo.mObjects.size() << std::endl;
266)   std::cout << "  pixel: " << gLayerPixel.mObjects.size() << std::endl;
267)   std::cout << "  cable: " << gLayerCable.mObjects.size() << std::endl;
268)   std::cout << "  network: " << gLayerNetwork.mObjects.size() << std::endl;
269)   std::cout << "  distributor:" << std::endl;
270)   std::map<unsigned int, Layer>::const_iterator itDistri;
271)   for (itDistri = gLayerDistributors.begin();
272)        itDistri != gLayerDistributors.end(); ++itDistri)

273)     std::cout << "    0x" << std::hex << itDistri->first << std::dec << ": "

274)               << itDistri->second.mObjects.size() << std::endl;
275) 
276)   return SUCCESS;
277) }
278) 

279) /**
280)  * @brief create a chain
281)  * @param[in] chain chain to create
282)  * @param[in] pObjCable cable to first pixel

283)  * @return SUCCESS on success, other value on error

284)  */

285) static int createChain(Chain &chain, const Object *pObjCable)

286) {
287)   // add all pixels
288)   const Object *pObjPixel = NULL;
289)   while (true) {
290) 
291)     // find pixels connected to cable
292)     std::vector<Layer::Intersection> intersectsPixels;
293)     gLayerPixel.getIntersections(pObjCable, intersectsPixels);
294) 
295)     // remove last pixel from results
296)     std::vector<Layer::Intersection>::iterator itPixel;
297)     for (itPixel = intersectsPixels.begin();
298)          itPixel != intersectsPixels.end(); ++itPixel) {
299)       if (itPixel->pObj == pObjPixel) {
300)         itPixel = intersectsPixels.erase(itPixel);
301)         if (itPixel == intersectsPixels.end())
302)           break;
303)       }
304)     }
305) 
306)     // end of chain
307)     if (intersectsPixels.size() < 1)

308)       return SUCCESS;

309) 
310)     // more than one next pixel
311)     if (intersectsPixels.size() > 1) {
312)       std::cerr << "pixel cable connects multiple pixels ("
313)                 << intersectsPixels[0].pt.mX << ","
314)                 << intersectsPixels[0].pt.mY << ")" << std::endl;

315)       return ERR_PROC;

316)     }
317) 
318)     // pixel found
319)     pObjPixel = intersectsPixels[0].pObj;
320) 
321)     // add pixel to chain

322)     chain.addPixel(Pixel(pObjPixel));

323) 
324)     // find cables connected to pixel
325)     std::vector<Layer::Intersection> intersectsCables;
326)     gLayerCable.getIntersections(pObjPixel, intersectsCables);
327) 
328)     // remove last cable from results
329)     std::vector<Layer::Intersection>::iterator itCable;
330)     for (itCable = intersectsCables.begin();
331)          itCable != intersectsCables.end(); ++itCable) {
332)       if (itCable->pObj == pObjCable) {
333)         itCable = intersectsCables.erase(itCable);
334)         if (itCable == intersectsCables.end())
335)           break;
336)       }
337)     }
338) 
339)     // end of chain
340)     if (intersectsCables.size() < 1)

341)       return SUCCESS;

342) 
343)     // more than one next pixel
344)     if (intersectsCables.size() > 1) {
345)       std::cerr << "pixel connected to multiple pixel cables ("
346)                 << intersectsCables[0].pt.mX << ","
347)                 << intersectsCables[0].pt.mY << ")" << std::endl;

348)       return ERR_PROC;

349)     }
350) 
351)     // next cable found
352)     pObjCable = intersectsCables[0].pObj;
353) 
354)   } // while (true)
355) }
356) 
357) /// sort helper for distributor/cables intersections

358) static bool intersectsCablesSort(const Layer::Intersection& i1,
359)                                  const Layer::Intersection& i2)

360) {

361)   return i1.pt.abs_sq() < i2.pt.abs_sq();

362) }
363) 
364) /**
365)  * @brief create a distributor
366)  * @param[in] distri distributor to create
367)  * @param[in] pLayer layer containing distributor
368)  * @param[in] pixels number of pixels per chain

369)  * @return SUCCESS on success, other value on error

370)  */

371) static int createDistri(Distri &distri, const Layer *pLayer,
372)                         unsigned int pixels)

373) {
374)   // must have exactly one object
375)   if (pLayer->mObjects.size() != 1) {

376)     std::cerr << "layer of distributor 0x" << std::hex << distri.getNo()

377)               << std::dec << " contains no object or multiple objects"
378)               << std::endl;

379)     return ERR_PROC;

380)   }
381)   const Object *pObjDistri = pLayer->mObjects[0];
382) 
383)   // get location of network connection
384)   std::vector<Layer::Intersection> intersectsNet;
385)   gLayerNetwork.getIntersections(pObjDistri, intersectsNet);
386)   if (intersectsNet.size() != 1) {

387)     std::cerr << "distributor 0x" << std::hex << distri.getNo() << std::dec

388)               << "has no network connection or multiple network connections"
389)               << std::endl;

390)     return ERR_PROC;

391)   }
392)   Point ptNetwork = intersectsNet[0].pt;
393) 
394)   // get cables to pixel chains
395)   std::vector<Layer::Intersection> intersectsCables;
396)   gLayerCable.getIntersections(pObjDistri, intersectsCables);
397) 
398)   // sort cables according to distance to network
399)   std::vector<Layer::Intersection>::iterator itIntersect;
400)   for (itIntersect = intersectsCables.begin();
401)        itIntersect != intersectsCables.end(); ++itIntersect)
402)     itIntersect->pt -= ptNetwork;
403)   std::sort(intersectsCables.begin(), intersectsCables.end(),
404)             intersectsCablesSort);
405) 
406)   // create chains
407)   bool err = false;
408)   for (itIntersect = intersectsCables.begin();
409)        itIntersect != intersectsCables.end(); ++itIntersect) {

410)     distri.addChain(Chain(pixels));
411)     if (createChain(distri.accessLastChain(), itIntersect->pObj) != 0)

412)       err = true;
413)   }
414) 

415)   return err ? ERR_PROC : SUCCESS;
416) }
417) 
418) /**
419)  * @brief make config file object from DXF layers
420)  * @param[in] width width of logical video frame
421)  * @param[in] height height of logical video frame
422)  * @param[in] chains number of chains (outputs) per distributor
423)  * @param[in] pixels number of pixels in one chain
424)  *                                    (i.e. connected to one output)

425)  * @param[out] boundsVideo bounds of video screen object

426)  * @param[out] distris distributor objects
427)  * @return true on success, false on error
428)  */
429) static bool makeObjects(unsigned int width, unsigned int height,
430)                         unsigned int chains, unsigned int pixels,

431)                         Box &boundsVideo, std::vector<Distri> &distris)

432) {
433)   // get origin and size of pixels in video
434)   gLayerVideo.getBounds(boundsVideo);
435)   Point ptPixel0(boundsVideo.mBL.mX, boundsVideo.mTR.mY);
436)   Point ptPixelSz = boundsVideo.mTR - boundsVideo.mBL;
437)   ptPixelSz.mX /= (double)width;
438)   ptPixelSz.mY /= (double)height;
439)   ptPixelSz.mY *= -1;
440)   std::cout << "video bounds: "
441)             << boundsVideo.mBL.mX << "," << boundsVideo.mBL.mY
442)             << " " << boundsVideo.mTR.mX << "," << boundsVideo.mTR.mY
443)             << std::endl;
444) 
445)   // create distributors
446)   bool ok = true;
447)   std::map<unsigned int, Layer>::const_iterator itDistri;
448)   for (itDistri = gLayerDistributors.begin();
449)        itDistri != gLayerDistributors.end(); ++itDistri) {
450)     distris.push_back(Distri(itDistri->first, chains, pixels));
451)     if (createDistri(distris.back(), &itDistri->second, pixels) != SUCCESS) {
452)       ok = false;
453)     }
454)   }
455) 
456)   // obtain pixel coordinates
457)   std::vector<Distri>::iterator itD;
458)   for (itD = distris.begin(); itD != distris.end(); ++itD)
459)     if (itD->pixCoord(ptPixel0, ptPixelSz, width, height) != 0)
460)       ok = false;
461) 
462)   // count pixels connected to distributors and compare to total pixels
463)   size_t distri_pixels = 0;
464)   for (itD = distris.begin(); itD != distris.end(); ++itD)
465)     distri_pixels += itD->countPixels();
466)   std::cout << "pixels connected to distributors: "
467)             << distri_pixels << std::endl;
468)   if (distri_pixels != gLayerPixel.mObjects.size()) {
469)     std::cerr << "number of connected pixels (" << distri_pixels
470)               << ") does not match total number of pixels ("
471)               << gLayerPixel.mObjects.size() << ")" << std::endl;
472)     ok = false;
473)   }
474) 
475)   // output extra error message if errors were detected
476)   if (! ok) {
477)     std::cerr << "ERRORs were found" << std::endl;
478)   }
479) 
480)   return ok;

481) }
482) 
483) /**
484)  * @brief write config file
485)  * @param[in] width width of video in pixels
486)  * @param[in] height height of video in pixels
487)  * @param[in] distris distributor objects

488)  * @param[in] strCfgFileName name of config file

489)  * @reutrn SUCCESS on success, other value on error

490)  */

491) static int writeCfg(unsigned int width, unsigned int height,
492)                     const std::vector<Distri> &distris,
493)                     const std::string & strCfgFileName)

494) {

495)   // open output file

496)   std::ofstream strm(strCfgFileName.c_str(), std::ios::out);
497)   if (!strm.is_open()) {
498)     std::cerr << "could not open \"" << strCfgFileName
499)               << "\" for wrinting" << std::endl;

500)     return ERR_FILE_OPEN;

501)   }
502) 
503)   // video size
504)   strm << "size = " << width << "," << height << std::endl
505)        << std::endl;
506) 
507)   // distributors
508)   std::vector<Distri>::const_iterator itD;
509)   for (itD = distris.begin(); itD != distris.end(); ++itD)
510)     itD->writeDistri(strm);
511)   strm << std::endl;
512) 
513)   // mappings
514)   for (itD = distris.begin(); itD != distris.end(); ++itD)
515)     itD->writeMapping(strm);
516)   strm << std::endl;
517) 
518)   // pixels
519)   for (itD = distris.begin(); itD != distris.end(); ++itD)
520)     itD->writePixels(strm);
521)   strm << std::endl;
522) 
523)   strm.close();

524)   return SUCCESS;

525) }
526) 

527) /**
528)  * @brief write simulator config file
529)  * @param[in] distris distributor objects
530)  * @param[in] boundsVideo bounds of video screen object
531)  * @param[in] strSimCfgFileName name of simulator config file
532)  * @reutrn SUCCESS on success, other value on error
533)  */
534) static int writeSimCfg(const std::vector<Distri> &distris,
535)                        const Box & boundsVideo,
536)                        const std::string & strSimCfgFileName)
537) {

538)   /* make video bounds quadratic
539)      in order to keep aspect ratio of simulator image */
540)   Box boundsVideoQuad = boundsVideo.expandQuadratic();
541) 

542)   // open output file
543)   std::ofstream strm(strSimCfgFileName.c_str(), std::ios::out);
544)   if (!strm.is_open()) {
545)     std::cerr << "could not open \"" << strSimCfgFileName
546)               << "\" for wrinting" << std::endl;
547)     return ERR_FILE_OPEN;
548)   }
549) 
550)   // distributors
551)   std::vector<Distri>::const_iterator itD;
552)   for (itD = distris.begin(); itD != distris.end(); ++itD)
553)     itD->writeDistri(strm);
554)   strm << std::endl;
555) 
556)   // mappings
557)   for (itD = distris.begin(); itD != distris.end(); ++itD)
558)     itD->writeMapping(strm);
559)   strm << std::endl;
560) 
561)   // simulated pixels
562)   for (itD = distris.begin(); itD != distris.end(); ++itD)

563)     itD->writeSimPixels(strm, boundsVideoQuad);

564)   strm << std::endl;
565) 
566)   strm.close();
567)   return SUCCESS;
568) }
569) 

570) /**
571)  * @brief main program
572)  * @param[in] argc number of parameters
573)  * @param[in] argv parameter values

574)  * @return SUCCESS on success, other value on error

575)  */
576) int main(int argc, char *argv[])
577) {
578)   // get parameters

579)   bool arg_err = 0, bDxfFileName = false, bCfgFileName = false,
580)                     bSimCfgFileName= false;
581)   std::string strDxfFileName, strCfgFileName, strSimCfgFileName;
582)   // old usage
583)   if (argc == 3) {
584)     std::cerr << "warning: old usage, consider using \"-d\" and \"-c\" options" << std::endl;
585)     strDxfFileName = argv[1];
586)     bDxfFileName = true;
587)     strCfgFileName = argv[2];
588)     bCfgFileName = true;
589)   } else {
590)     int argi;
591)     for (argi = 1; argi < argc; ++argi) {
592)       if (strcmp(argv[argi], "-c") == 0) {
593)         ++argi;
594)         if (argi < argc) {
595)           strCfgFileName = argv[argi];
596)           bCfgFileName = true;
597)         } else {
598)           std::cerr << "error: missing argument for \"-c\"" << std::endl;
599)         }
600)       } else if (strcmp(argv[argi], "-d") == 0) {
601)         ++argi;
602)         if (argi < argc) {
603)           strDxfFileName = argv[argi];
604)           bDxfFileName = true;
605)         } else {
606)           std::cerr << "error: missing argument for \"-d\"" << std::endl;
607)         }
608)       } else if (strcmp(argv[argi], "-s") == 0) {
609)         ++argi;
610)         if (argi < argc) {
611)           strSimCfgFileName = argv[argi];
612)           bSimCfgFileName = true;
613)         } else {
614)           std::cerr << "error: missing argument for \"-s\"" << std::endl;
615)         }
616)       } else {

617)         std::cerr << "error: unknown option \"" << argv[argi]
618)                   << "\", call without arguments for usage" << std::endl;

619)         arg_err = true;
620)       }
621)     } // for argi
622)     if (! bDxfFileName) {
623)       std::cerr << "error: missing input drawing (\"-d\")" << std::endl;
624)       arg_err = true;
625)     }
626)   }
627)   // output help on error
628)   if (arg_err) {

629)     std::cerr << "EtherPix config file generator "
630)               << ETPCG_VER_MAJ << "."
631)               << ETPCG_VER_MIN << "."
632)               << ETPCG_VER_REV << std::endl

633)               << "usage: " << argv[0] << " [options]" << std::endl
634)               << "options: -c <config.etp>       configuration file (output)" << std::endl
635)               << "         -d <drawing.dxf>      schematic drawing (input)" << std::endl
636)               << "         -s <sim_config.etps>  simulator configuration (output)" << std::endl
637)               << "old usage: " << argv[0] << " <schematic_drawing.dxf> <config.etp>"

638)               << std::endl;

639)     return ERR_USAGE;

640)   }
641) 
642)   // read DXF file

643)   unsigned int width, height, chains, pixels;

644)   int ret = readDXF(strDxfFileName, width, height, chains, pixels);
645)   if (ret != SUCCESS) {
646)     return ret;

647)   }
648) 

649)   // make config file objects from DXF layers

650)   Box boundsVideo;

651)   std::vector<Distri> distris;

652)   if (! makeObjects(width, height, chains, pixels, boundsVideo, distris)) {

653)     return ERR_PROC;

654)   }
655) 

656)   // write config file

657)   if (bCfgFileName) {
658)     ret = writeCfg(width, height, distris, strCfgFileName);

659)     if (ret != SUCCESS) {

660)       return ret;
661)     }
662)   }
663) 
664)   // write simulator config file
665)   if (bSimCfgFileName) {
666)     ret = writeSimCfg(distris, boundsVideo, strSimCfgFileName);

667)     if (ret != SUCCESS) {

668)       return ret;
669)     }

670)   }

671) 
672)   return SUCCESS;