Rev 779 | Rev 1104 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1 | |||
3 | Werner | 2 | #include "mainwindow.h" |
3 | #include "ui_mainwindow.h" |
||
4 | |||
259 | werner | 5 | #include <QtGui> |
6 | #include <QtXml> |
||
30 | Werner | 7 | #include <imagestamp.h> |
19 | Werner | 8 | #include "lightroom.h" |
105 | Werner | 9 | #include "stampcontainer.h" |
10 | #include "speciesset.h" |
||
11 | #include "exception.h" |
||
39 | Werner | 12 | #include "paintarea.h" |
400 | werner | 13 | #include "globalsettings.h" |
772 | werner | 14 | //GlobalSettings *GlobalSettings::mInstance = 0; |
39 | Werner | 15 | |
9 | Werner | 16 | // global settings |
17 | QDomDocument xmldoc; |
||
18 | QDomNode xmlparams; |
||
20 | Werner | 19 | |
20 | // global Object pointers |
||
21 | LightRoom *lightroom = 0; |
||
39 | Werner | 22 | StampContainer *stamp_container=0; |
40 | Werner | 23 | StampContainer *reader_stamp_container=0; |
90 | Werner | 24 | QList<Species*> tree_species; |
20 | Werner | 25 | |
40 | Werner | 26 | double distance(const QPointF &a, const QPointF &b) |
27 | { |
||
28 | return sqrt( (a.x()-b.x())*(a.x()-b.x()) + (a.y()-b.y())*(a.y()-b.y()) ); |
||
29 | } |
||
39 | Werner | 30 | |
9 | Werner | 31 | QString setting(const QString& paramname) |
32 | { |
||
33 | if (!xmlparams.isNull()) |
||
34 | return xmlparams.firstChildElement(paramname).text(); |
||
35 | else |
||
36 | return "ERROR"; |
||
37 | } |
||
30 | Werner | 38 | |
31 | Werner | 39 | |
6 | Werner | 40 | double nrandom(const float& p1, const float& p2) |
41 | { |
||
42 | return p1 + (p2-p1)*(rand()/float(RAND_MAX)); |
||
43 | } |
||
44 | |||
7 | Werner | 45 | void myMessageOutput(QtMsgType type, const char *msg) |
46 | { |
||
40 | Werner | 47 | switch (type) { |
7 | Werner | 48 | case QtDebugMsg: |
40 | Werner | 49 | MainWindow::logSpace()->appendPlainText(QString(msg)); |
50 | MainWindow::logSpace()->ensureCursorVisible(); |
||
7 | Werner | 51 | break; |
52 | case QtWarningMsg: |
||
87 | Werner | 53 | MainWindow::logSpace()->appendPlainText(QString("WARNING: %1").arg(msg)); |
54 | MainWindow::logSpace()->ensureCursorVisible(); |
||
55 | fprintf(stderr, "WARNING: %s\n", msg); |
||
7 | Werner | 56 | break; |
57 | case QtCriticalMsg: |
||
58 | fprintf(stderr, "Critical: %s\n", msg); |
||
59 | break; |
||
60 | case QtFatalMsg: |
||
61 | fprintf(stderr, "Fatal: %s\n", msg); |
||
62 | abort(); |
||
40 | Werner | 63 | } |
7 | Werner | 64 | |
40 | Werner | 65 | |
7 | Werner | 66 | } |
67 | |||
68 | QPlainTextEdit *MainWindow::mLogSpace=NULL; |
||
69 | |||
70 | QPlainTextEdit* MainWindow::logSpace() |
||
71 | { |
||
72 | return mLogSpace; |
||
73 | } |
||
74 | |||
3 | Werner | 75 | MainWindow::MainWindow(QWidget *parent) |
76 | : QMainWindow(parent), ui(new Ui::MainWindowClass) |
||
77 | { |
||
78 | ui->setupUi(this); |
||
259 | werner | 79 | |
3 | Werner | 80 | connect( ui->PaintWidget, SIGNAL(needsPainting(QPainter&)), |
81 | this, SLOT(repaintArea(QPainter&)) ); |
||
40 | Werner | 82 | |
113 | Werner | 83 | |
7 | Werner | 84 | mLogSpace = ui->logOutput; |
409 | werner | 85 | qInstallMsgHandler(myMessageOutput); |
19 | Werner | 86 | // load xml file |
87 | xmldoc.clear(); |
||
119 | Werner | 88 | QString argText = QApplication::arguments().last(); |
200 | werner | 89 | if (QApplication::arguments().count()>1 && !argText.isEmpty()) |
119 | Werner | 90 | ui->initFileName->setText(argText); |
91 | |||
19 | Werner | 92 | QString xmlFile = Helper::loadTextFile(ui->initFileName->text()); |
3 | Werner | 93 | |
65 | Werner | 94 | if (!xmlFile.isEmpty()) { |
95 | ui->iniEdit->setPlainText(xmlFile); |
||
19 | Werner | 96 | |
65 | Werner | 97 | if (!xmldoc.setContent(xmlFile)) { |
98 | QMessageBox::information(this, "title text", "Cannot set content of XML file " + ui->initFileName->text()); |
||
99 | return; |
||
100 | } |
||
19 | Werner | 101 | } |
102 | |||
20 | Werner | 103 | on_actionEdit_XML_settings_triggered(); |
72 | Werner | 104 | // update |
19 | Werner | 105 | |
118 | Werner | 106 | qDebug() << "threadcount: " << QThread::idealThreadCount(); |
107 | |||
3 | Werner | 108 | } |
109 | |||
110 | MainWindow::~MainWindow() |
||
111 | { |
||
112 | delete ui; |
||
20 | Werner | 113 | if (lightroom) |
114 | delete lightroom; |
||
3 | Werner | 115 | } |
116 | |||
117 | void MainWindow::on_applyXML_clicked() |
||
118 | { |
||
9 | Werner | 119 | xmldoc.clear(); |
3 | Werner | 120 | // load for edit |
28 | Werner | 121 | QString xml = ui->iniEdit->toPlainText(); |
122 | QString errMsg; |
||
123 | int errLine, errCol; |
||
124 | if (!xmldoc.setContent(xml, &errMsg, &errLine, &errCol)) { |
||
125 | QMessageBox::information(this, "Error applying XML", |
||
126 | QString("Error applying xml line %1, col %2.\nMessage: %3").arg(errLine).arg(errCol).arg(errMsg)); |
||
3 | Werner | 127 | return; |
128 | } |
||
259 | werner | 129 | qDebug() << "XML file read."; |
28 | Werner | 130 | } |
3 | Werner | 131 | |
132 | |||
133 | void MainWindow::on_saveFile_clicked() |
||
134 | { |
||
135 | QString content = ui->iniEdit->toPlainText(); |
||
136 | if (!content.isEmpty()) |
||
16 | Werner | 137 | Helper::saveToTextFile(ui->initFileName->text(), content); |
3 | Werner | 138 | |
139 | } |
||
140 | |||
72 | Werner | 141 | |
772 | werner | 142 | void MainWindow::repaintArea(QPainter &) |
20 | Werner | 143 | { |
144 | // select drawing type... |
||
145 | switch (m_gfxtype) { |
||
146 | case 0: // paint FON cells |
||
259 | werner | 147 | return; |
25 | Werner | 148 | case 1: // paint Lightroom - studio --- painting is done on the background image of PaintArea |
20 | Werner | 149 | break; |
150 | case 2: // paint Lightroom |
||
151 | default: break; // no painting |
||
152 | } |
||
49 | Werner | 153 | // fix viewpoint |
154 | vp.setScreenRect(ui->PaintWidget->rect()); |
||
20 | Werner | 155 | } |
156 | |||
19 | Werner | 157 | void MainWindow::on_actionLightroom_triggered() |
158 | { |
||
159 | ui->editStack->setCurrentIndex(1); |
||
160 | ui->headerCaption->setText("Lightroom"); |
||
20 | Werner | 161 | m_gfxtype = 1; |
162 | ui->PaintWidget->update(); |
||
19 | Werner | 163 | } |
164 | |||
165 | void MainWindow::on_actionEdit_XML_settings_triggered() |
||
166 | { |
||
129 | Werner | 167 | |
19 | Werner | 168 | ui->editStack->setCurrentIndex(0); |
129 | Werner | 169 | |
20 | Werner | 170 | ui->PaintWidget->update(); |
19 | Werner | 171 | } |
172 | |||
173 | void MainWindow::on_actionFON_action_triggered() |
||
174 | { |
||
175 | ui->editStack->setCurrentIndex(2); |
||
176 | ui->headerCaption->setText("Field Of Neighborhood test environment"); |
||
20 | Werner | 177 | m_gfxtype = 0; |
178 | ui->PaintWidget->update(); |
||
19 | Werner | 179 | |
180 | } |
||
181 | |||
182 | void MainWindow::on_pbCreateLightroom_clicked() |
||
183 | { |
||
259 | werner | 184 | if (xmldoc.isNull()) { |
185 | Helper::msg("!!XML not loaded!!"); |
||
186 | return; |
||
187 | } |
||
188 | QDomElement docLightroom = xmldoc.documentElement(); // top element |
||
189 | |||
19 | Werner | 190 | if (docLightroom.isNull()) MSGRETURN("cant find node 'lightroom' in xml"); |
191 | int x,y,z; |
||
192 | x = docLightroom.firstChildElement("size").attribute("x").toInt(); |
||
193 | y = docLightroom.firstChildElement("size").attribute("y").toInt(); |
||
194 | z = docLightroom.firstChildElement("size").attribute("z").toInt(); |
||
32 | Werner | 195 | double cellsize = docLightroom.firstChildElement("size").attribute("cellsize").toDouble(); |
19 | Werner | 196 | |
197 | int hemisize = docLightroom.firstChildElement("hemigrid").attribute("size").toInt(); |
||
198 | double lat = docLightroom.firstChildElement("hemigrid").attribute("latitude").toFloat(); |
||
199 | double diffus = docLightroom.firstChildElement("hemigrid").attribute("diffus").toFloat(); |
||
200 | |||
201 | // create a lightroom object... |
||
20 | Werner | 202 | if (!lightroom) |
203 | lightroom = new LightRoom(); |
||
204 | |||
21 | Werner | 205 | lightroom->setup(x,y,z,cellsize, |
19 | Werner | 206 | hemisize,lat,diffus); |
25 | Werner | 207 | LightRoomObject *lro = new LightRoomObject(); |
28 | Werner | 208 | lro->setuptree(40., 20., "5*(1-x*x)"); |
25 | Werner | 209 | lightroom->setLightRoomObject(lro); |
23 | Werner | 210 | |
19 | Werner | 211 | qDebug() << "Lightroom setup complete"; |
212 | } |
||
23 | Werner | 213 | |
214 | void MainWindow::on_testLRO_clicked() |
||
215 | { |
||
24 | Werner | 216 | // setup a lightroom object, and do some tests... |
26 | Werner | 217 | double x = ui->lr_x->text().toDouble(); |
218 | double y = ui->lr_y->text().toDouble(); |
||
219 | double z = ui->lr_z->text().toDouble(); |
||
220 | double azi = ui->lrAzim->text().toDouble(); |
||
221 | double elev = ui->lrElevation->text().toDouble(); |
||
222 | |||
23 | Werner | 223 | LightRoomObject lro; |
25 | Werner | 224 | lro.setuptree(40., 10., "5*(1-x*x)"); |
26 | Werner | 225 | qDebug()<<"x:"<<x<<"y:"<<y<<"z:"<<z<<"azimuth:"<<azi<<"elevation:"<<elev << lro.hittest(x,y,z,RAD(azi), RAD(elev)); |
226 | //qDebug()<<"-10,-10,0 - azimuth 42, elev: 45:" << lro.hittest(-10,-10,0,RAD(42), RAD(45)); |
||
23 | Werner | 227 | } |
25 | Werner | 228 | |
229 | void MainWindow::on_lroTestHemi_clicked() |
||
230 | { |
||
231 | double x = double(ui->lrSliderX->value());// ui->lr_x->text().toDouble(); |
||
232 | double y = ui->lrSliderY->value(); |
||
233 | double z = ui->lrSliderZ->value(); |
||
234 | ui->lr_x->setText(QString::number(x)); |
||
235 | ui->lr_y->setText(QString::number(y)); |
||
236 | ui->lr_z->setText(QString::number(z)); |
||
237 | if (!lightroom) |
||
238 | MSGRETURN("Lightroom NULL!"); |
||
239 | DebugTimer t("single point"); |
||
31 | Werner | 240 | double res = lightroom->calculateGridAtPoint(x,y,z); |
241 | ui->lrHemiValue->setText(QString::number(res)); |
||
25 | Werner | 242 | // now paint... |
243 | //ui->PaintWidget->drawImage(); |
||
244 | lightroom->shadowGrid().paintGrid(ui->PaintWidget->drawImage()); |
||
245 | ui->PaintWidget->update(); // repaint |
||
246 | //qDebug() << lightroom->shadowGrid().dumpGrid(); |
||
247 | |||
248 | } |
||
249 | void MainWindow::on_lrLightGrid_clicked() |
||
250 | { |
||
251 | lightroom->solarGrid().paintGrid(ui->PaintWidget->drawImage()); |
||
252 | ui->PaintWidget->update(); // repaint |
||
253 | qDebug() << lightroom->solarGrid().dumpGrid(); |
||
254 | } |
||
255 | |||
256 | void MainWindow::on_lrCalcFullGrid_clicked() |
||
257 | { |
||
258 | if (!lightroom) |
||
259 | MSGRETURN("Lightroom NULL!"); |
||
260 | lightroom->calculateFullGrid(); |
||
27 | Werner | 261 | float maxvalue = lightroom->result().max(); |
262 | qDebug() << "maxvalue" << maxvalue; |
||
263 | const FloatGrid &result = lightroom->result(); |
||
264 | QString res; |
||
265 | for (int x=0;x<result.sizeX();x++){ |
||
266 | for (int y=0;y<result.sizeY();y++) { |
||
267 | res+=QString::number(result.constValueAtIndex(QPoint(x,y))) + ";"; |
||
268 | } |
||
269 | res+="\n"; |
||
270 | } |
||
271 | qDebug()<< res; |
||
25 | Werner | 272 | } |
273 | |||
274 | |||
259 | werner | 275 | void MainWindow::on_lrProcess_clicked() |
104 | Werner | 276 | { |
259 | werner | 277 | if (xmldoc.isNull()) { |
278 | Helper::msg("!!XML not loaded!!"); |
||
279 | return; |
||
121 | Werner | 280 | } |
104 | Werner | 281 | |
31 | Werner | 282 | QDomElement docElem = xmldoc.documentElement(); |
400 | werner | 283 | |
259 | werner | 284 | QString output_file = docElem.firstChildElement("outputStamp").text(); |
285 | QDomElement tree = docElem.firstChildElement("trees").firstChildElement("tree"); |
||
35 | Werner | 286 | |
259 | werner | 287 | double cut_threshold = docElem.firstChildElement("cutvalue").text().toDouble(); |
412 | werner | 288 | QString cut_mode = docElem.firstChildElement("cutoffMode").text(); |
404 | werner | 289 | QString agg_mode = docElem.firstChildElement("aggregationMode").text(); |
290 | int mode=-1; |
||
291 | if (agg_mode=="sum") { |
||
292 | mode=1; |
||
293 | qDebug() << "aggregation mode set to 'sum'"; |
||
294 | } |
||
295 | if (agg_mode=="mean") { |
||
296 | qDebug() << "aggregation mode set to 'mean'"; |
||
297 | mode=0; |
||
298 | } |
||
299 | if (mode==-1) { |
||
300 | Helper::msg("Error: invalid or no aggregationMode specified!"); |
||
301 | return; |
||
302 | } |
||
303 | |||
259 | werner | 304 | QString stamp_desc = docElem.firstChildElement("desc").text(); |
305 | QString binaryReaderStampFile = docElem.firstChildElement("readerStamp").text(); |
||
44 | Werner | 306 | qDebug() << "cutting stamps when averaged absoulte value of rings is below"<<cut_threshold; |
259 | werner | 307 | qDebug() << "reading binary stamp reader file" << binaryReaderStampFile; |
308 | |||
400 | werner | 309 | if (!Helper::question(QString("Create writer stamps?\ntarget=%1, \nreader stamps=%2").arg(output_file, binaryReaderStampFile))) |
259 | werner | 310 | return; |
64 | Werner | 311 | float crown, height, bhd; |
400 | werner | 312 | QString formula, name; |
31 | Werner | 313 | |
314 | LightRoomObject *lro = new LightRoomObject(); |
||
315 | lightroom->setLightRoomObject(lro); |
||
404 | werner | 316 | lightroom->setAggregationMode(mode); |
31 | Werner | 317 | |
42 | Werner | 318 | StampContainer readers; |
259 | werner | 319 | |
42 | Werner | 320 | QFile infile(binaryReaderStampFile); |
321 | infile.open(QIODevice::ReadOnly); |
||
322 | QDataStream in(&infile); |
||
323 | readers.load(in); |
||
324 | infile.close(); |
||
325 | |||
34 | Werner | 326 | StampContainer container; |
327 | container.useLookup(false); // disable lookup table (not necessary for creation) |
||
328 | |||
50 | Werner | 329 | DebugTimer creation_time("total creation of stamps"); |
330 | |||
30 | Werner | 331 | while (!tree.isNull()) { |
31 | Werner | 332 | name = tree.attribute("name"); |
333 | height = tree.attribute("h").toDouble(); |
||
334 | crown = tree.attribute("crown").toDouble(); |
||
34 | Werner | 335 | bhd = tree.attribute("bhd").toDouble(); |
31 | Werner | 336 | formula = tree.attribute("formula"); |
337 | /////////////////////////// |
||
338 | lro->setuptree(height, crown, formula); |
||
339 | qDebug() << "start" << name; |
||
340 | lightroom->calculateFullGrid(); |
||
35 | Werner | 341 | |
52 | Werner | 342 | // store as textfile: |
343 | //result = gridToString( lightroom->result() ); |
||
344 | //Helper::saveToTextFile(path + "\\ " + name + ".txt", result); |
||
345 | |||
346 | // save stamp as image: |
||
347 | //QImage img = gridToImage( lightroom->result() ); |
||
348 | //img.save(path + "\\ " + name + ".jpg", "JPG", 100); |
||
349 | |||
38 | Werner | 350 | // averaged copy: FloatGrid gr = lightroom->result().averaged(avg_cells); |
351 | const FloatGrid &gr = lightroom->result(); |
||
37 | Werner | 352 | // calculate sums... |
38 | Werner | 353 | QVector<double> sums; // stores sum per ring (rectangle) |
354 | QVector<double> rel_sum; // stores sum/px |
||
412 | werner | 355 | QVector<double> max_vals; // stores values in north direction |
37 | Werner | 356 | double sum; |
38 | Werner | 357 | int ring_count; |
132 | Werner | 358 | double total_sum = 0.; |
37 | Werner | 359 | for (int o=0; o<gr.sizeX()/2; o++) { |
38 | Werner | 360 | sum = 0; ring_count=0; |
37 | Werner | 361 | // top and bottom |
362 | for (int i=o; i<gr.sizeX()-o; i++) { |
||
363 | sum += gr(i, o); |
||
364 | sum += gr(i, gr.sizeX()-1-o); |
||
38 | Werner | 365 | ring_count+=2; |
37 | Werner | 366 | } |
367 | // left, right :: do not calculate the edges two times.... |
||
368 | for (int i=o+1; i<gr.sizeX()-o-1; i++) { |
||
369 | sum += gr(o, i); |
||
370 | sum += gr(gr.sizeX()-1-o, i); |
||
38 | Werner | 371 | ring_count+=2; |
37 | Werner | 372 | } |
132 | Werner | 373 | total_sum += sum; |
37 | Werner | 374 | sums.push_back(sum); |
38 | Werner | 375 | rel_sum.push_back(sum / double(ring_count) ); |
412 | werner | 376 | max_vals.push_back(gr(gr.sizeX()/2, gr.sizeX()-1-o)); // bottom.... |
37 | Werner | 377 | } |
38 | Werner | 378 | if (gr.sizeX()% 2) { |
132 | Werner | 379 | total_sum += gr(gr.sizeX()/2, gr.sizeX()/2); // center pixel for unevenly sized grids |
37 | Werner | 380 | sums.push_back(gr(gr.sizeX()/2, gr.sizeX()/2)); // center pixel for unevenly sized grids |
38 | Werner | 381 | rel_sum.push_back(gr(gr.sizeX()/2, gr.sizeX()/2)); // center pixel for unevenly sized grids |
412 | werner | 382 | max_vals.push_back(gr(gr.sizeX()/2, gr.sizeX()/2)); // center pixel |
38 | Werner | 383 | } |
384 | int end_ring, target_grid_size; |
||
132 | Werner | 385 | /* version < 20090905: average ring value |
38 | Werner | 386 | for (end_ring=0;end_ring<rel_sum.count();end_ring++) |
44 | Werner | 387 | if (rel_sum[end_ring]>cut_threshold) |
38 | Werner | 388 | break; |
132 | Werner | 389 | end_ring = rel_sum.count() - end_ring; // */ |
390 | |||
391 | // version > 20090905: based on total area |
||
412 | werner | 392 | if (cut_mode == "sum") { |
393 | double rsum = 0; |
||
394 | for (end_ring=0;end_ring<sums.count();end_ring++) { |
||
395 | rsum += sums[end_ring]; |
||
396 | // threshold: sum of influence > threshold |
||
397 | if (rsum>cut_threshold*total_sum) |
||
398 | break; |
||
399 | } |
||
400 | } else if (cut_mode == "north") { |
||
401 | // 20100527: based on direction with maximum values |
||
402 | for (end_ring=0;end_ring<sums.count();end_ring++) { |
||
403 | if (max_vals[end_ring]>cut_threshold) |
||
404 | break; |
||
405 | } |
||
406 | |||
407 | } else { |
||
408 | qDebug() << "ERROR: invalid cutoffMode (possible values: sum, north)!!! Exiting."; |
||
409 | return; |
||
132 | Werner | 410 | } |
411 | end_ring = sums.count() - end_ring; |
||
412 | if (end_ring<2) // minimum ring-count=2 (i.e. 9pixel) |
||
413 | end_ring=2; |
||
414 | |||
38 | Werner | 415 | target_grid_size = 2*end_ring - 1; // e.g. 3rd ring -> 5x5-matrix |
412 | werner | 416 | qDebug() << "break at ring" << end_ring << "with cutoff mode" << cut_mode; |
417 | qDebug() << "circle sum relsum maxvals"; |
||
37 | Werner | 418 | for (int i=0;i<sums.count();i++) |
412 | werner | 419 | qDebug() << i << sums[i] << rel_sum[i] << max_vals[i]; |
35 | Werner | 420 | |
37 | Werner | 421 | |
34 | Werner | 422 | // test: use subpixel averages .... |
423 | /* |
||
33 | Werner | 424 | FloatGrid gr3x3 = lightroom->result().averaged(3); |
32 | Werner | 425 | QImage img3x3 = gridToImage( gr3x3 ); |
426 | img3x3.save(path + "\\ " + name + "_3x3.jpg", "JPG", 100); |
||
427 | Helper::saveToTextFile(path + "\\ " + name + "_3x3.txt", gridToString(gr3x3)); |
||
428 | result=""; |
||
429 | for (int x=0;x<3;x++) |
||
430 | for (int y=0;y<3;y++) { |
||
33 | Werner | 431 | FloatGrid gr3x3 = lightroom->result().averaged(3,x,y); |
32 | Werner | 432 | result+="\r\n" + gridToString(gr3x3); |
433 | |||
434 | } |
||
34 | Werner | 435 | Helper::saveToTextFile(QString("%1\\%2_shift.txt").arg(path, name), result); */ |
436 | |||
437 | // store to container |
||
38 | Werner | 438 | Stamp *stamp = stampFromGrid(gr, target_grid_size); |
439 | if (!stamp) |
||
440 | return; |
||
40 | Werner | 441 | qDebug() << "created stamp with size (n x n)" << stamp->size() << "in an data-block of:" << stamp->dataSize(); |
42 | Werner | 442 | // process reading area |
443 | double maxradius = lro->maxRadius(); |
||
444 | const Stamp *readerstamp = readers.readerStamp(maxradius); |
||
445 | if (readerstamp) { |
||
446 | int offset = stamp->offset() - readerstamp->offset(); |
||
447 | qDebug() << "fetching read-sum. offset stamp" << stamp->offset() << "offset readerstamp" << readerstamp->offset(); |
||
448 | double sum = 0; |
||
449 | for (int x=0;x<readerstamp->size();x++) |
||
450 | for (int y=0;y<readerstamp->size(); y++) |
||
451 | sum += *(readerstamp->data(x,y)) * *(stamp->data(x+offset, y+offset)); |
||
452 | qDebug() << "sum of reader-area over stamp" << sum; |
||
453 | } else qDebug() << "!!! no readerstamp available!!!"; |
||
43 | Werner | 454 | |
35 | Werner | 455 | double hd = qRound( height*100 / bhd ); |
65 | Werner | 456 | container.addStamp(stamp,bhd, hd, lro->maxRadius()); // 3rd param was: , |
31 | Werner | 457 | /////////////////////////// |
30 | Werner | 458 | tree = tree.nextSiblingElement("tree"); |
459 | } |
||
31 | Werner | 460 | qDebug() << "finished!!!"; |
34 | Werner | 461 | // write container to a file.... |
259 | werner | 462 | QFile file(output_file); |
34 | Werner | 463 | file.open(QIODevice::WriteOnly); |
63 | Werner | 464 | container.setDescription(stamp_desc); // provided in xml... |
34 | Werner | 465 | QDataStream out(&file); // we will serialize the data into the file |
466 | container.save(out); |
||
467 | file.close(); |
||
35 | Werner | 468 | qDebug() << "current content of the container:"; |
469 | qDebug() << container.dump(); |
||
470 | } |
||
34 | Werner | 471 | |
259 | werner | 472 | |
35 | Werner | 473 | void MainWindow::on_lrLoadStamps_clicked() |
474 | { |
||
40 | Werner | 475 | { |
54 | Werner | 476 | QString fileName = Helper::fileDialog("Name for binary stamp file"); |
477 | if (fileName.isEmpty()) |
||
478 | return; |
||
479 | QFile infile(fileName); |
||
41 | Werner | 480 | infile.open(QIODevice::ReadOnly); |
481 | QDataStream in(&infile); |
||
482 | StampContainer container; |
||
483 | container.load(in); |
||
484 | infile.close(); |
||
54 | Werner | 485 | qDebug() << "Dumping content of Stamp-container" << fileName; |
41 | Werner | 486 | qDebug() << container.dump(); |
487 | // and the reader-stamps.... |
||
488 | } |
||
40 | Werner | 489 | } |
490 | |||
491 | |||
492 | // create "reader" stamps.... |
||
493 | void MainWindow::on_lrReadStamps_clicked() |
||
494 | { |
||
495 | FloatGrid grid; // use copy ctor |
||
802 | werner | 496 | grid.setup(QRectF(-21., -21, 42, 42),2.); // 0/0 is the center of the center cell |
35 | Werner | 497 | StampContainer container; |
40 | Werner | 498 | int totcount=0; |
499 | DebugTimer t; |
||
309 | werner | 500 | for (double radius=0.5; radius<=15; radius+=0.1) { |
40 | Werner | 501 | qDebug() << "creation of reader stamp for radius" << radius; |
502 | grid.initialize(0.); |
||
503 | float x,y; |
||
504 | int tested=0, yes=0; |
||
802 | werner | 505 | // the center point of the cell where the center of the tree is, |
506 | // is at 1m/1m (at a cell width of 2m) |
||
40 | Werner | 507 | for (x=-radius;x<=radius;x+=0.01) |
508 | for (y=-radius;y<=radius;y+=0.01) { |
||
509 | tested++; |
||
510 | if ( x*x + y*y < radius*radius) { |
||
511 | grid.valueAt(x,y)++; yes++; |
||
512 | } |
||
513 | } |
||
802 | werner | 514 | qDebug() << "tested" << tested << "hit" << yes << "ratio" << 4.*yes/double(tested); // that should be pi, right? |
40 | Werner | 515 | totcount+=tested; |
516 | FloatGrid ngrid = grid.normalized(1.); // normalize with 1 |
||
517 | // create a stamp with a fitting size |
||
518 | Stamp *stamp; |
||
54 | Werner | 519 | int width=11; |
802 | werner | 520 | // radius: 0..<1: 1, >=1 <3: 3, >=3 < 5: 5, ... |
521 | width = (((int)radius+1)/2)*2 + 1; |
||
522 | |||
40 | Werner | 523 | stamp = stampFromGrid(ngrid,width); |
524 | // save stamp |
||
525 | container.addReaderStamp(stamp, radius); |
||
526 | |||
527 | } // for (radius) |
||
528 | qDebug() << "tested a total of" << totcount; |
||
259 | werner | 529 | QString targetFile = xmldoc.documentElement().firstChildElement("readerStamp").text(); |
802 | werner | 530 | if (!Helper::question(QString("Save readerfile to %1?").arg(targetFile))) { |
531 | qDebug() << container.dump(); |
||
259 | werner | 532 | return; |
802 | werner | 533 | } |
259 | werner | 534 | QFile file(targetFile); |
400 | werner | 535 | if (!file.open(QIODevice::WriteOnly)) { |
536 | qDebug() << "Error opening reader file" << targetFile << "with error:" << file.errorString(); |
||
537 | } |
||
40 | Werner | 538 | QDataStream out(&file); // we will serialize the data into the file |
309 | werner | 539 | container.setDescription("Reader-stamps for crown-radii ranging from 0.5m to 15m, stepwidth is 0.1m."); |
40 | Werner | 540 | container.save(out); |
400 | werner | 541 | file.close(); |
35 | Werner | 542 | qDebug() << container.dump(); |
40 | Werner | 543 | |
544 | |||
30 | Werner | 545 | } |
58 | Werner | 546 | |
547 | |||
65 | Werner | 548 | |
549 | void MainWindow::on_openFile_clicked() |
||
550 | { |
||
551 | QString fileName = Helper::fileDialog("select XML-ini file for FonStudio..."); |
||
552 | if (fileName.isEmpty()) |
||
553 | return; |
||
554 | ui->initFileName->setText(fileName); |
||
555 | QString xmlFile = Helper::loadTextFile(ui->initFileName->text()); |
||
556 | ui->iniEdit->setPlainText(xmlFile); |
||
557 | } |
||
67 | Werner | 558 | |
400 | werner | 559 | |
560 | void MainWindow::on_reloadFile_clicked() |
||
561 | { |
||
562 | QString xmlFile = Helper::loadTextFile(ui->initFileName->text()); |
||
563 | ui->iniEdit->setPlainText(xmlFile); |
||
564 | } |