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 << "    " << itDistri->first << ": "
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)               << "contains no object or multiple objects" << std::endl;

378)     return ERR_PROC;

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

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

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

389)     return ERR_PROC;

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

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

411)       err = true;
412)   }
413) 

414)   return err ? ERR_PROC : SUCCESS;
415) }
416) 
417) /**
418)  * @brief make config file object from DXF layers
419)  * @param[in] width width of logical video frame
420)  * @param[in] height height of logical video frame
421)  * @param[in] chains number of chains (outputs) per distributor
422)  * @param[in] pixels number of pixels in one chain
423)  *                                    (i.e. connected to one output)
424)  * @param[out] distris distributor objects
425)  * @return true on success, false on error
426)  */
427) static bool makeObjects(unsigned int width, unsigned int height,
428)                         unsigned int chains, unsigned int pixels,
429)                         std::vector<Distri> &distris)
430) {
431)   // get origin and size of pixels in video
432)   Box boundsVideo;
433)   gLayerVideo.getBounds(boundsVideo);
434)   Point ptPixel0(boundsVideo.mBL.mX, boundsVideo.mTR.mY);
435)   Point ptPixelSz = boundsVideo.mTR - boundsVideo.mBL;
436)   ptPixelSz.mX /= (double)width;
437)   ptPixelSz.mY /= (double)height;
438)   ptPixelSz.mY *= -1;
439)   std::cout << "video bounds: "
440)             << boundsVideo.mBL.mX << "," << boundsVideo.mBL.mY
441)             << " " << boundsVideo.mTR.mX << "," << boundsVideo.mTR.mY
442)             << std::endl;
443) 
444)   // create distributors
445)   bool ok = true;
446)   std::map<unsigned int, Layer>::const_iterator itDistri;
447)   for (itDistri = gLayerDistributors.begin();
448)        itDistri != gLayerDistributors.end(); ++itDistri) {
449)     distris.push_back(Distri(itDistri->first, chains, pixels));
450)     if (createDistri(distris.back(), &itDistri->second, pixels) != SUCCESS) {
451)       ok = false;
452)     }
453)   }
454) 
455)   // obtain pixel coordinates
456)   std::vector<Distri>::iterator itD;
457)   for (itD = distris.begin(); itD != distris.end(); ++itD)
458)     if (itD->pixCoord(ptPixel0, ptPixelSz, width, height) != 0)
459)       ok = false;
460) 
461)   // count pixels connected to distributors and compare to total pixels
462)   size_t distri_pixels = 0;
463)   for (itD = distris.begin(); itD != distris.end(); ++itD)
464)     distri_pixels += itD->countPixels();
465)   std::cout << "pixels connected to distributors: "
466)             << distri_pixels << std::endl;
467)   if (distri_pixels != gLayerPixel.mObjects.size()) {
468)     std::cerr << "number of connected pixels (" << distri_pixels
469)               << ") does not match total number of pixels ("
470)               << gLayerPixel.mObjects.size() << ")" << std::endl;
471)     ok = false;
472)   }
473) 
474)   // output extra error message if errors were detected
475)   if (! ok) {
476)     std::cerr << "ERRORs were found" << std::endl;
477)   }
478) 
479)   return ok;

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

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

488)  */

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

492) {

493)   // open output file

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

498)     return ERR_FILE_OPEN;

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

522)   return SUCCESS;

523) }
524) 
525) /**
526)  * @brief main program
527)  * @param[in] argc number of parameters
528)  * @param[in] argv parameter values

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

530)  */
531) int main(int argc, char *argv[])
532) {
533)   // get parameters

534)   if (argc != 3) {

535)     std::cerr << "EtherPix config file generator "
536)               << ETPCG_VER_MAJ << "."
537)               << ETPCG_VER_MIN << "."
538)               << ETPCG_VER_REV << std::endl
539)               << "usage: " << argv[0] << " <schematic_drawing.dxf> <config.etp>"

540)               << std::endl;

541)     return ERR_USAGE;

542)   }
543)   std::string strDxfFileName = argv[1];

544)   std::string strCfgFileName = argv[2];

545) 
546)   // read DXF file

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

548)   int ret = readDXF(strDxfFileName, width, height, chains, pixels);
549)   if (ret != SUCCESS) {
550)     return ret;

551)   }
552) 

553)   // make config file objects from DXF layers

554)   std::vector<Distri> distris;

555)   if (! makeObjects(width, height, chains, pixels, distris)) {
556)     return ERR_PROC;

557)   }
558) 

559)   // write config file

560)   ret = writeCfg(width, height, distris, strCfgFileName);
561)   if ( ret != SUCCESS) {
562)     return ret;

563)   }

564) 
565)   return SUCCESS;