1
2
3 #include "toonz/sceneproperties.h"
4
5 // TnzLib includes
6 #include "toonz/cleanupparameters.h"
7 #include "toonz/tcenterlinevectorizer.h"
8 #include "toonz/captureparameters.h"
9 #include "toonz/tcamera.h"
10 #include "toonz/tstageobjecttree.h"
11 #include "toonz/txshleveltypes.h"
12 #include "toonz/preferences.h"
13 #include "cleanuppalette.h"
14 #include "toonz/boardsettings.h"
15
16 // TnzBase includes
17 #include "toutputproperties.h"
18 #include "trasterfx.h"
19 #include "tscanner.h"
20
21 // TnzCore includes
22 #include "tstream.h"
23 #include "tpalette.h"
24 #include "tproperty.h"
25 #include "tiio.h"
26
27 //=============================================================================
28
TSceneProperties()29 TSceneProperties::TSceneProperties()
30 : m_cleanupParameters(new CleanupParameters())
31 , m_scanParameters(new TScannerParameters())
32 , m_vectorizerParameters(new VectorizerParameters())
33 , m_captureParameters(new CaptureParameters())
34 , m_outputProp(new TOutputProperties())
35 , m_previewProp(new TOutputProperties())
36 , m_bgColor(255, 255, 255, 0)
37 , m_markerDistance(6)
38 , m_markerOffset(0)
39 , m_fullcolorSubsampling(1)
40 , m_tlvSubsampling(1)
41 , m_fieldGuideSize(16)
42 , m_fieldGuideAspectRatio(1.77778)
43 , m_columnColorFilterOnRender(false)
44 , m_camCapSaveInPath() {
45 // Default color
46 m_notesColor.push_back(TPixel32(255, 235, 140));
47 m_notesColor.push_back(TPixel32(255, 160, 120));
48 m_notesColor.push_back(TPixel32(255, 180, 190));
49 m_notesColor.push_back(TPixel32(135, 205, 250));
50 m_notesColor.push_back(TPixel32(145, 240, 145));
51 m_notesColor.push_back(TPixel32(130, 255, 210));
52 m_notesColor.push_back(TPixel32(150, 245, 255));
53 }
54
55 //-----------------------------------------------------------------------------
56
~TSceneProperties()57 TSceneProperties::~TSceneProperties() {
58 delete m_cleanupParameters;
59 delete m_scanParameters;
60 delete m_vectorizerParameters;
61 delete m_captureParameters;
62 clearPointerContainer(m_cameras);
63 delete m_outputProp;
64 delete m_previewProp;
65 }
66
67 //-----------------------------------------------------------------------------
68
assign(const TSceneProperties * sprop)69 void TSceneProperties::assign(const TSceneProperties *sprop) {
70 assert(sprop);
71
72 m_hGuides = sprop->m_hGuides;
73 m_vGuides = sprop->m_vGuides;
74 *m_outputProp = *sprop->m_outputProp;
75 *m_previewProp = *sprop->m_previewProp;
76
77 m_cleanupParameters->assign(sprop->m_cleanupParameters);
78 m_scanParameters->assign(sprop->m_scanParameters);
79
80 assert(sprop->m_vectorizerParameters);
81 *m_vectorizerParameters = *sprop->m_vectorizerParameters;
82
83 if (sprop != this) {
84 m_cameras = sprop->m_cameras;
85 for (int i = 0; i < (int)m_cameras.size(); i++)
86 m_cameras[i] = new TCamera(*m_cameras[i]);
87 }
88 m_bgColor = sprop->m_bgColor;
89 m_markerDistance = sprop->m_markerDistance;
90 m_markerOffset = sprop->m_markerOffset;
91 m_fullcolorSubsampling = sprop->m_fullcolorSubsampling;
92 m_tlvSubsampling = sprop->m_tlvSubsampling;
93 m_fieldGuideSize = sprop->m_fieldGuideSize;
94 m_fieldGuideAspectRatio = sprop->m_fieldGuideAspectRatio;
95 m_columnColorFilterOnRender = sprop->m_columnColorFilterOnRender;
96 int i;
97 for (i = 0; i < m_notesColor.size(); i++)
98 m_notesColor.replace(i, sprop->getNoteColor(i));
99 }
100
101 //-----------------------------------------------------------------------------
102
onInitialize()103 void TSceneProperties::onInitialize() {
104 // set initial output folder to $scenefolder when the scene folder mode is set
105 // in user preferences
106 if (Preferences::instance()->getPathAliasPriority() ==
107 Preferences::SceneFolderAlias &&
108 !TFilePath("$scenefolder").isAncestorOf(m_outputProp->getPath())) {
109 std::string ext = m_outputProp->getPath().getDottedType();
110 m_outputProp->setPath(TFilePath("$scenefolder/") + ext);
111 }
112
113 // m_scanParameters->adaptToCurrentScanner();
114 }
115
116 //-----------------------------------------------------------------------------
117
setBgColor(const TPixel32 & color)118 void TSceneProperties::setBgColor(const TPixel32 &color) { m_bgColor = color; }
119
120 //-----------------------------------------------------------------------------
121
setMarkers(int distance,int offset)122 void TSceneProperties::setMarkers(int distance, int offset) {
123 m_markerDistance = distance;
124 m_markerOffset = offset;
125 }
126
127 //-----------------------------------------------------------------------------
128
setFullcolorSubsampling(int s)129 void TSceneProperties::setFullcolorSubsampling(int s) {
130 assert(1 <= s && s <= 100);
131 m_fullcolorSubsampling = tcrop(s, 1, 100);
132 }
133
134 //-----------------------------------------------------------------------------
135
setTlvSubsampling(int s)136 void TSceneProperties::setTlvSubsampling(int s) {
137 assert(1 <= s && s <= 100);
138 m_tlvSubsampling = tcrop(s, 1, 100);
139 }
140
141 //-----------------------------------------------------------------------------
142
setFieldGuideSize(int size)143 void TSceneProperties::setFieldGuideSize(int size) {
144 assert(1 <= size && size <= 100);
145 m_fieldGuideSize = tcrop(size, 1, 100);
146 }
147
148 //-----------------------------------------------------------------------------
149
setFieldGuideAspectRatio(double ar)150 void TSceneProperties::setFieldGuideAspectRatio(double ar) {
151 assert(ar >= 0);
152 if (ar <= 0) ar = 1;
153 m_fieldGuideAspectRatio = ar;
154 }
155
156 //-----------------------------------------------------------------------------
157
saveData(TOStream & os) const158 void TSceneProperties::saveData(TOStream &os) const {
159 if (!m_hGuides.empty()) {
160 os.openChild("hGuides");
161 for (int i = 0; i < (int)m_hGuides.size(); i++) os << m_hGuides[i];
162 os.closeChild();
163 }
164 if (!m_vGuides.empty()) {
165 os.openChild("vGuides");
166 for (int i = 0; i < (int)m_vGuides.size(); i++) os << m_vGuides[i];
167 os.closeChild();
168 }
169
170 int i;
171 if (!m_cameras.empty()) {
172 os.openChild("cameras");
173 for (i = 0; i < (int)m_cameras.size(); i++) {
174 os.openChild("camera");
175 m_cameras[i]->saveData(os);
176 os.closeChild();
177 }
178 os.closeChild();
179 }
180
181 os.openChild("outputs");
182 std::vector<TOutputProperties *> outputs;
183 outputs.push_back(getOutputProperties());
184 outputs.push_back(getPreviewProperties());
185 for (i = 0; i < (int)outputs.size(); i++) {
186 TOutputProperties &out = *outputs[i];
187 const TRenderSettings &rs = out.getRenderSettings();
188 std::map<std::string, std::string> attr;
189 attr["name"] = i == 0 ? "main" : "preview";
190 os.openChild("output", attr);
191
192 TFilePath outPath = out.getPath();
193 int from, to, step;
194 out.getRange(from, to, step);
195 os.child("range") << from << to;
196 os.child("step") << step;
197 os.child("shrink") << rs.m_shrinkX;
198 os.child("applyShrinkToViewer") << (rs.m_applyShrinkToViewer ? 1 : 0);
199 os.child("fps") << out.getFrameRate();
200 os.child("path") << outPath;
201 os.child("bpp") << rs.m_bpp;
202 os.child("multimedia") << out.getMultimediaRendering();
203 os.child("threadsIndex") << out.getThreadIndex();
204 os.child("maxTileSizeIndex") << out.getMaxTileSizeIndex();
205 os.child("subcameraPrev") << (out.isSubcameraPreview() ? 1 : 0);
206 os.child("stereoscopic") << (rs.m_stereoscopic ? 1 : 0)
207 << rs.m_stereoscopicShift;
208
209 switch (rs.m_quality) {
210 case TRenderSettings::StandardResampleQuality:
211 os.child("resquality") << (int)0;
212 break;
213 case TRenderSettings::ImprovedResampleQuality:
214 os.child("resquality") << (int)1;
215 break;
216 case TRenderSettings::HighResampleQuality:
217 os.child("resquality") << (int)2;
218 break;
219 case TRenderSettings::Triangle_FilterResampleQuality:
220 os.child("resquality") << (int)100;
221 break;
222 case TRenderSettings::Mitchell_FilterResampleQuality:
223 os.child("resquality") << (int)101;
224 break;
225 case TRenderSettings::Cubic5_FilterResampleQuality:
226 os.child("resquality") << (int)102;
227 break;
228 case TRenderSettings::Cubic75_FilterResampleQuality:
229 os.child("resquality") << (int)103;
230 break;
231 case TRenderSettings::Cubic1_FilterResampleQuality:
232 os.child("resquality") << (int)104;
233 break;
234 case TRenderSettings::Hann2_FilterResampleQuality:
235 os.child("resquality") << (int)105;
236 break;
237 case TRenderSettings::Hann3_FilterResampleQuality:
238 os.child("resquality") << (int)106;
239 break;
240 case TRenderSettings::Hamming2_FilterResampleQuality:
241 os.child("resquality") << (int)107;
242 break;
243 case TRenderSettings::Hamming3_FilterResampleQuality:
244 os.child("resquality") << (int)108;
245 break;
246 case TRenderSettings::Lanczos2_FilterResampleQuality:
247 os.child("resquality") << (int)109;
248 break;
249 case TRenderSettings::Lanczos3_FilterResampleQuality:
250 os.child("resquality") << (int)110;
251 break;
252 case TRenderSettings::Gauss_FilterResampleQuality:
253 os.child("resquality") << (int)111;
254 break;
255 case TRenderSettings::ClosestPixel_FilterResampleQuality:
256 os.child("resquality") << (int)112;
257 break;
258 case TRenderSettings::Bilinear_FilterResampleQuality:
259 os.child("resquality") << (int)113;
260 break;
261 default:
262 assert(false);
263 }
264 switch (rs.m_fieldPrevalence) {
265 case TRenderSettings::NoField:
266 os.child("fieldprevalence") << (int)0;
267 break;
268 case TRenderSettings::EvenField:
269 os.child("fieldprevalence") << (int)1;
270 break;
271 case TRenderSettings::OddField:
272 os.child("fieldprevalence") << (int)2;
273 break;
274 default:
275 assert(false);
276 }
277 os.child("gamma") << rs.m_gamma;
278 os.child("timestretch") << rs.m_timeStretchFrom << rs.m_timeStretchTo;
279
280 if (out.getOffset() != 0) os.child("offset") << out.getOffset();
281
282 os.openChild("formatsProperties");
283 std::vector<std::string> fileExtensions;
284 out.getFileFormatPropertiesExtensions(fileExtensions);
285 for (int i = 0; i < (int)fileExtensions.size(); i++) {
286 std::string ext = fileExtensions[i];
287 TPropertyGroup *pg = out.getFileFormatProperties(ext);
288 assert(pg);
289 std::map<std::string, std::string> attr;
290 attr["ext"] = ext;
291 os.openChild("formatProperties", attr);
292 pg->saveData(os);
293 os.closeChild();
294 }
295 os.closeChild();
296
297 if (out.getBoardSettings() && out.getBoardSettings()->getDuration()) {
298 os.openChild("clapperboardSettings");
299 out.getBoardSettings()->saveData(os);
300 os.closeChild();
301 }
302
303 os.closeChild(); // </output>
304 }
305 os.closeChild();
306 os.openChild("cleanupParameters");
307 m_cleanupParameters->saveData(os);
308 os.closeChild();
309 os.openChild("scanParameters");
310 m_scanParameters->saveData(os);
311 os.closeChild();
312 os.openChild("vectorizerParameters");
313 m_vectorizerParameters->saveData(os);
314 os.closeChild();
315 os.child("bgColor") << m_bgColor;
316 os.child("markers") << m_markerDistance << m_markerOffset;
317 os.child("subsampling") << m_fullcolorSubsampling << m_tlvSubsampling;
318 os.child("fieldguide") << m_fieldGuideSize << m_fieldGuideAspectRatio;
319 if (m_columnColorFilterOnRender) os.child("columnColorFilterOnRender") << 1;
320 if (!m_camCapSaveInPath.isEmpty())
321 os.child("cameraCaputureSaveInPath") << m_camCapSaveInPath;
322
323 os.openChild("noteColors");
324 for (i = 0; i < m_notesColor.size(); i++) os << m_notesColor.at(i);
325 os.closeChild();
326 }
327
328 //-----------------------------------------------------------------------------
329 /*! Set all scene properties elements, to information contained in \b TIStream
330 \b is.
331 \sa saveData()
332 */
loadData(TIStream & is,bool isLoadingProject)333 void TSceneProperties::loadData(TIStream &is, bool isLoadingProject) {
334 TSceneProperties defaultProperties;
335 assign(&defaultProperties);
336
337 int globFrom = -1, globTo = 0, globStep = 1;
338 double globFrameRate = -1;
339 std::string tagName;
340 *m_outputProp = *m_previewProp = TOutputProperties();
341 while (is.matchTag(tagName)) {
342 if (tagName == "projectPath") {
343 TFilePath projectPath;
344 is >> projectPath;
345 } else if (tagName == "range") {
346 is >> globFrom >> globTo;
347 } // backCompatibility: prima range e fps non erano in Output
348 else if (tagName == "step") {
349 is >> globStep;
350 } else if (tagName == "fps") {
351 is >> globFrameRate;
352 } else if (tagName == "bgColor") {
353 is >> m_bgColor;
354 } else if (tagName == "viewerBgColor" || tagName == "previewBgColor" ||
355 tagName == "chessboardColor1" ||
356 tagName == "chessboardColor2") // back compatibility
357 {
358 TPixel32 dummy;
359 is >> dummy;
360 } else if (tagName == "markers") {
361 is >> m_markerDistance >> m_markerOffset;
362 } else if (tagName == "subsampling") {
363 is >> m_fullcolorSubsampling >> m_tlvSubsampling;
364 } else if (tagName == "fieldguide") {
365 is >> m_fieldGuideSize >> m_fieldGuideAspectRatio;
366 } else if (tagName == "columnColorFilterOnRender") {
367 int val;
368 is >> val;
369 enableColumnColorFilterOnRender(val == 1);
370 } else if (tagName == "safearea") {
371 double dummy1, dummy2;
372 is >> dummy1 >> dummy2;
373 } // back compatibility
374 else if (tagName == "columnIconLoadingPolicy") {
375 int dummy;
376 is >> dummy;
377 } // back compatibility
378 else if (tagName == "playrange") // back compatibility
379 {
380 std::string dummy;
381 is >> globFrom >> globTo >> dummy;
382 } else if (tagName == "camera") // back compatibility with tab 2.2
383 {
384 clearPointerContainer(m_cameras);
385 m_cameras.clear();
386 TCamera *camera = new TCamera();
387 m_cameras.push_back(camera);
388 TDimension res(0, 0);
389 is >> res.lx >> res.ly;
390 camera->setRes(res);
391 double cameraDpi = 36.0;
392 camera->setSize(TDimensionD(res.lx / cameraDpi, res.ly / cameraDpi));
393 } else if (tagName == "playRange") {
394 int playR0, playR1;
395 is >> playR0 >> playR1;
396 } else if (tagName == "hGuides" || tagName == "vGuides") {
397 Guides &guides = tagName == "hGuides" ? m_hGuides : m_vGuides;
398 while (!is.matchEndTag()) {
399 double g;
400 is >> g;
401 guides.push_back(g);
402 }
403 continue;
404 } else if (tagName == "cameras") {
405 clearPointerContainer(m_cameras);
406 m_cameras.clear();
407 while (is.matchTag(tagName)) {
408 if (tagName == "camera") {
409 TCamera *camera = new TCamera();
410 m_cameras.push_back(camera);
411 camera->loadData(is);
412 } // if "camera"
413 else
414 throw TException("unexpected property tag: " + tagName);
415 is.closeChild();
416 }
417 } else if (tagName == "outputs" || tagName == "outputStreams") {
418 while (is.matchTag(tagName)) {
419 if (tagName == "output" || tagName == "outputStream") {
420 TOutputProperties dummyOut;
421 TOutputProperties *outPtr = &dummyOut;
422 std::string name = is.getTagAttribute("name");
423 if (name == "preview")
424 outPtr = m_previewProp;
425 else if (name == "main")
426 outPtr = m_outputProp;
427 TOutputProperties &out = *outPtr;
428 TRenderSettings renderSettings;
429 if (globFrom != -1)
430 out.setRange(globFrom, globTo, globStep);
431 else if (globStep != 1) {
432 int from, to, dummy;
433 out.getRange(from, to, dummy);
434 out.setRange(from, to, globStep);
435 }
436
437 if (globFrameRate != -1) out.setFrameRate(globFrameRate);
438 while (is.matchTag(tagName)) {
439 if (tagName == "camera") {
440 int dummy;
441 is >> dummy;
442 } // per compatibilita'
443 else if (tagName == "cameraData") { // per compatibilita'
444 while (is.matchTag(tagName)) {
445 if (tagName == "size") {
446 TDimensionD size(0, 0);
447 is >> size.lx >> size.ly;
448 } else if (tagName == "res") {
449 TDimension res(0, 0);
450 is >> res.lx >> res.ly;
451 }
452 is.closeChild();
453 }
454 } else if (tagName == "path") {
455 TFilePath fp;
456 is >> fp;
457 std::string ext = fp.getUndottedType();
458 TPropertyGroup *pg = out.getFileFormatProperties(ext);
459 if (ext == "avi" && pg->getPropertyCount() != 1)
460 fp = fp.withType("tif");
461 out.setPath(fp);
462 } else if (tagName == "offset") {
463 int j;
464 is >> j;
465 out.setOffset(j);
466 } else if (tagName == "range") {
467 int from, to, step, dummy;
468 is >> from >> to;
469 out.getRange(dummy, dummy, step);
470 out.setRange(from, to, step);
471 } else if (tagName == "step") {
472 int dummy, from, to, step;
473 is >> step;
474 out.getRange(from, to, dummy);
475 out.setRange(from, to, step);
476 } else if (tagName == "shrink") {
477 int shrink;
478 is >> shrink;
479 renderSettings.m_shrinkX = renderSettings.m_shrinkY = shrink;
480 } else if (tagName == "applyShrinkToViewer") {
481 int applyShrinkToViewer;
482 is >> applyShrinkToViewer;
483 renderSettings.m_applyShrinkToViewer = (applyShrinkToViewer != 0);
484 } else if (tagName == "fps") {
485 double j;
486 is >> j;
487 out.setFrameRate(j);
488 } else if (tagName == "bpp") {
489 int j;
490 is >> j;
491 if (j == 32 || j == 64) renderSettings.m_bpp = j;
492 } else if (tagName == "multimedia") {
493 int j;
494 is >> j;
495 out.setMultimediaRendering(j);
496 } else if (tagName == "threadsIndex") {
497 int j;
498 is >> j;
499 out.setThreadIndex(j);
500 } else if (tagName == "maxTileSizeIndex") {
501 int j;
502 is >> j;
503 out.setMaxTileSizeIndex(j);
504 } else if (tagName == "subcameraPrev") {
505 int j;
506 is >> j;
507 out.setSubcameraPreview(j != 0);
508 } else if (tagName == "resquality") {
509 int j;
510 is >> j;
511 switch (j) {
512 case 0:
513 renderSettings.m_quality =
514 TRenderSettings::StandardResampleQuality;
515 break;
516 case 1:
517 renderSettings.m_quality =
518 TRenderSettings::ImprovedResampleQuality;
519 break;
520 case 2:
521 renderSettings.m_quality = TRenderSettings::HighResampleQuality;
522 break;
523 case 100:
524 renderSettings.m_quality =
525 TRenderSettings::Triangle_FilterResampleQuality;
526 break;
527 case 101:
528 renderSettings.m_quality =
529 TRenderSettings::Mitchell_FilterResampleQuality;
530 break;
531 case 102:
532 renderSettings.m_quality =
533 TRenderSettings::Cubic5_FilterResampleQuality;
534 break;
535 case 103:
536 renderSettings.m_quality =
537 TRenderSettings::Cubic75_FilterResampleQuality;
538 break;
539 case 104:
540 renderSettings.m_quality =
541 TRenderSettings::Cubic1_FilterResampleQuality;
542 break;
543 case 105:
544 renderSettings.m_quality =
545 TRenderSettings::Hann2_FilterResampleQuality;
546 break;
547 case 106:
548 renderSettings.m_quality =
549 TRenderSettings::Hann3_FilterResampleQuality;
550 break;
551 case 107:
552 renderSettings.m_quality =
553 TRenderSettings::Hamming2_FilterResampleQuality;
554 break;
555 case 108:
556 renderSettings.m_quality =
557 TRenderSettings::Hamming3_FilterResampleQuality;
558 break;
559 case 109:
560 renderSettings.m_quality =
561 TRenderSettings::Lanczos2_FilterResampleQuality;
562 break;
563 case 110:
564 renderSettings.m_quality =
565 TRenderSettings::Lanczos3_FilterResampleQuality;
566 break;
567 case 111:
568 renderSettings.m_quality =
569 TRenderSettings::Gauss_FilterResampleQuality;
570 break;
571 case 112:
572 renderSettings.m_quality =
573 TRenderSettings::ClosestPixel_FilterResampleQuality;
574 break;
575 case 113:
576 renderSettings.m_quality =
577 TRenderSettings::Bilinear_FilterResampleQuality;
578 break;
579 default:
580 renderSettings.m_quality =
581 TRenderSettings::StandardResampleQuality;
582 }
583 } else if (tagName == "fieldprevalence") {
584 int j;
585 is >> j;
586 switch (j) {
587 case 0:
588 renderSettings.m_fieldPrevalence = TRenderSettings::NoField;
589 break;
590 case 1:
591 renderSettings.m_fieldPrevalence = TRenderSettings::EvenField;
592 break;
593 case 2:
594 renderSettings.m_fieldPrevalence = TRenderSettings::OddField;
595 break;
596 default:
597 renderSettings.m_fieldPrevalence = TRenderSettings::NoField;
598 break;
599 }
600 } else if (tagName == "gamma") {
601 double g;
602 is >> g;
603 renderSettings.m_gamma = g;
604 } else if (tagName == "timestretch") {
605 double from, to;
606 is >> from >> to;
607 renderSettings.m_timeStretchFrom = from;
608 renderSettings.m_timeStretchTo = to;
609 } else if (tagName == "stereoscopic") {
610 int doit;
611 double val;
612 is >> doit >> val;
613 renderSettings.m_stereoscopic = (doit == 1);
614 renderSettings.m_stereoscopicShift = val;
615 }
616
617 // TODO: aggiungere la lettura della quality
618 else if (tagName == "res") { // obsoleto
619 TDimension d(0, 0);
620 is >> d.lx >> d.ly;
621 if (!is.eos()) {
622 std::string s;
623 is >> s;
624 }
625 } else if (tagName == "formatsProperties") {
626 while (is.matchTag(tagName)) {
627 if (tagName == "formatProperties") {
628 std::string ext = is.getTagAttribute("ext");
629 TPropertyGroup *pg = out.getFileFormatProperties(ext);
630 if (ext == "avi") {
631 TPropertyGroup appProperties;
632 appProperties.loadData(is);
633 if (pg->getPropertyCount() != 1 ||
634 appProperties.getPropertyCount() != 1) {
635 is.closeChild();
636 continue;
637 }
638 TEnumProperty *enumProp =
639 dynamic_cast<TEnumProperty *>(pg->getProperty(0));
640 TEnumProperty *enumAppProp = dynamic_cast<TEnumProperty *>(
641 appProperties.getProperty(0));
642 assert(enumAppProp && enumProp);
643 if (enumAppProp && enumProp) {
644 try {
645 enumProp->setValue(enumAppProp->getValue());
646 } catch (TProperty::RangeError &) {
647 }
648 } else
649 throw TException();
650 } else
651 pg->loadData(is);
652
653 ////////ここだ！
654 {
655 TPropertyGroup *refPg = Tiio::makeWriterProperties(ext);
656 pg->assignUINames(refPg);
657 delete refPg;
658 }
659
660 is.closeChild();
661 } else
662 throw TException("unexpected tag: " + tagName);
663 } // end while
664 } else if (tagName == "clapperboardSettings") {
665 assert(out.getBoardSettings());
666 out.getBoardSettings()->loadData(is);
667 } else {
668 throw TException("unexpected property tag: " + tagName);
669 }
670 is.closeChild();
671 }
672 if (renderSettings.m_timeStretchFrom ==
673 renderSettings.m_timeStretchTo &&
674 renderSettings.m_timeStretchTo == 1)
675 renderSettings.m_timeStretchFrom = renderSettings.m_timeStretchTo =
676 out.getFrameRate();
677
678 out.setRenderSettings(renderSettings);
679 } else
680 throw TException("unexpected property tag: " + tagName);
681 is.closeChild();
682 } // while (outputs/outputStreams)
683 } else if (tagName == "cleanupPalette") {
684 m_cleanupParameters->m_cleanupPalette->loadData(is);
685 } else if (tagName == "cleanupParameters") {
686 m_cleanupParameters->loadData(is, !isLoadingProject);
687 } else if (tagName == "scanParameters") {
688 // m_scanParameters->adaptToCurrentScanner(); Rallenta tutto!!!
689 m_scanParameters->loadData(is);
690 } else if (tagName == "vectorizerParameters") {
691 m_vectorizerParameters->loadData(is);
692 } else if (tagName == "captureParameters") {
693 m_captureParameters->loadData(is);
694 } else if (tagName == "defaultLevelParameters") {
695 // this
696 int type;
697 double width, height, dpi;
698 is >> type >> width >> height >> dpi;
699 } else if (tagName == "noteColors") {
700 int i = 0;
701 while (!is.eos()) {
702 TPixel32 color;
703 is >> color;
704 m_notesColor.replace(i, color);
705 i++;
706 }
707 assert(i == 7);
708 } else if (tagName == "cameraCaputureSaveInPath") {
709 is >> m_camCapSaveInPath;
710 } else {
711 throw TException("unexpected property tag: " + tagName);
712 }
713 is.closeChild();
714 }
715 }
716
717 //-----------------------------------------------------------------------------
718
cloneCamerasFrom(TStageObjectTree * stageObjects)719 void TSceneProperties::cloneCamerasFrom(TStageObjectTree *stageObjects) {
720 clearPointerContainer(m_cameras);
721 int cameraCount = stageObjects->getCameraCount();
722
723 int tmpCameraId = 0;
724
725 for (int i = 0; i < cameraCount;) {
726 /*-- カメラが見つからなかった場合、tmpCameraIdのみ進める --*/
727 if (!stageObjects->getStageObject(TStageObjectId::CameraId(tmpCameraId),
728 false)) {
729 tmpCameraId++;
730 continue;
731 }
732 TStageObject *cameraObject =
733 stageObjects->getStageObject(TStageObjectId::CameraId(tmpCameraId));
734 TCamera *camera = new TCamera(*cameraObject->getCamera());
735 m_cameras.push_back(camera);
736 /*-- カメラが見つかったので、i も tmpCameraId も進める --*/
737 i++;
738 tmpCameraId++;
739 }
740 }
741
742 //-----------------------------------------------------------------------------
743
cloneCamerasTo(TStageObjectTree * stageObjects) const744 void TSceneProperties::cloneCamerasTo(TStageObjectTree *stageObjects) const {
745 TDimension maxCameraRes(0, 0);
746
747 for (int i = 0; i < (int)m_cameras.size(); i++) {
748 TStageObject *cameraPegbar =
749 stageObjects->getStageObject(TStageObjectId::CameraId(i));
750 TCamera *camera = m_cameras[i];
751
752 TDimension cameraRes = camera->getRes();
753 bool modified = false;
754 if (maxCameraRes.lx > 0 && cameraRes.lx > maxCameraRes.lx) {
755 cameraRes.lx = maxCameraRes.lx;
756 modified = true;
757 }
758 if (maxCameraRes.ly > 0 && cameraRes.ly > maxCameraRes.ly) {
759 cameraRes.ly = maxCameraRes.ly;
760 modified = true;
761 }
762 if (modified) camera->setRes(cameraRes);
763
764 *cameraPegbar->getCamera() = *m_cameras[i];
765 }
766 }
767
768 //-----------------------------------------------------------------------------
769
getNoteColors() const770 QList<TPixel32> TSceneProperties::getNoteColors() const { return m_notesColor; }
771
772 //-----------------------------------------------------------------------------
773
getNoteColor(int colorIndex) const774 TPixel32 TSceneProperties::getNoteColor(int colorIndex) const {
775 return m_notesColor[colorIndex];
776 }
777
778 //-----------------------------------------------------------------------------
779
setNoteColor(TPixel32 color,int colorIndex)780 void TSceneProperties::setNoteColor(TPixel32 color, int colorIndex) {
781 m_notesColor[colorIndex] = color;
782 }
783