Kstars

fileutilitycameradata.cpp
1/*
2 SPDX-FileCopyrightText: 2023 Joseph McGee <joseph.mcgee@sbcglobal.net>
3
4 SPDX-License-Identifier: GPL-2.0-or-later
5*/
6
7#include <stdio.h>
8#include <string.h>
9#include <QLoggingCategory>
10#include <QDialog>
11#include <QDir>
12#include <QFile>
13#include <QtNetwork/QNetworkAccessManager>
14#include <QtNetwork/QNetworkRequest>
15#include <QtNetwork/QNetworkReply>
16#include <QStandardPaths>
17#include <QUrl>
18#include <QTimer>
19#include <QIODevice>
20#include <QDirIterator>
21#include <QXmlStreamWriter>
22#include <QXmlStreamReader>
23#include "fileutilitycameradata.h"
24#include "imagingcameradata.h"
25#include "cameragainreadnoise.h"
26#include "exposurecalculatordialog.h"
27#include <ekos_capture_debug.h>
28#include <sstream>
29#include <kspaths.h>
30
31/*
32 * Direct access to files on KDE/kstars git repository:
33 */
34QString const OptimalExposure::FileUtilityCameraData::cameraDataRemoteRepositoryList
35 = "https://api.github.com/repos/KDE/kstars/git/trees/master:kstars%2Fdata%2Fcameradata";
36
37QString const OptimalExposure::FileUtilityCameraData::cameraDataRemoteRepository
38 = "https://raw.githubusercontent.com/KDE/kstars/master/kstars/data/cameradata/";
39
40QString const OptimalExposure::FileUtilityCameraData::cameraApplicationDataRepository
41 = KSPaths::locate(QStandardPaths::AppDataLocation, QString("cameradata/"), QStandardPaths::LocateDirectory);
42
43QString const OptimalExposure::FileUtilityCameraData::cameraLocalDataRepository
44 = QDir(KSPaths::writableLocation(QStandardPaths::AppLocalDataLocation)).filePath("kstars/cameradata/");
45
46QStringList OptimalExposure::FileUtilityCameraData::getAvailableCameraFilesList()
47{
48 QStringList cameraDataFiles;
49 QStringList dirs;
50
51
52 dirs << KSPaths::locateAll(QStandardPaths::GenericDataLocation,
53 QString::fromLatin1("kstars/cameradata"),
54 QStandardPaths::LocateDirectory);
55
56 Q_FOREACH (const QString &dir, dirs)
57 {
58 QDirIterator it(dir, QStringList() << QLatin1String("*.xml"));
59
60 while (it.hasNext())
61 {
62 cameraDataFiles.append(it.next());
63 }
64 }
65
66 return(cameraDataFiles);
67}
68
69
70QString OptimalExposure::FileUtilityCameraData::cameraIdToCameraDataFileName(QString cameraId)
71{
72
73 // Replace spaces with "_" in the file name
74 QString aCameraDataFile = cameraId.replace(" ", "_");
75
76 if(!aCameraDataFile.endsWith(".xml"))
77 {
78 aCameraDataFile += ".xml";
79 }
80
81 return(aCameraDataFile);
82}
83
84QString OptimalExposure::FileUtilityCameraData::cameraDataFileNameToCameraId(QString cameraDataFileName)
85{
86 QFileInfo cameraDataFileInfo(cameraDataFileName);
87
88 // QString aCameraId = cameraDataFileName;
89
90 QString aCameraId = cameraDataFileInfo.baseName();
91
92 if(aCameraId.endsWith(".xml"))
93 aCameraId.truncate(aCameraId.length() - 4);
94
95 aCameraId = aCameraId.replace("_", " ");
96 return(aCameraId);
97}
98
99
100void OptimalExposure::FileUtilityCameraData::downloadRepositoryCameraDataFileList(
101 QDialog *aDialog)
102
103{
104
105 qCInfo(KSTARS_EKOS_CAPTURE) << "cameraDataRemoteRepositoryList: " <<
106 OptimalExposure::FileUtilityCameraData::cameraDataRemoteRepositoryList;
107 qCInfo(KSTARS_EKOS_CAPTURE) << "cameraDataRemoteRepository: " <<
108 OptimalExposure::FileUtilityCameraData::cameraDataRemoteRepository;
109 // qCInfo(KSTARS_EKOS_CAPTURE) << "cameraApplicationDataRepository: " << OptimalExposure::FileUtilityCameraData::cameraApplicationDataRepository;
110 qCInfo(KSTARS_EKOS_CAPTURE) << "cameraLocalDataRepository: " <<
111 OptimalExposure::FileUtilityCameraData::cameraLocalDataRepository;
112
113 // Using git tree to access camera file list, this approach requires parsing the tree
114 // string collect the xml (camera data) file names.
115
116 FileUtilityCameraDataDialog *activeDialog = static_cast<FileUtilityCameraDataDialog *> (aDialog);
117 activeDialog->setANetworkAccessManager(new QNetworkAccessManager(activeDialog));
118
119 QString aCameraDataRemoteFolderURL = OptimalExposure::FileUtilityCameraData::cameraDataRemoteRepositoryList;
120 qCInfo(KSTARS_EKOS_CAPTURE) << "Attempting access of camera data file repository " << aCameraDataRemoteFolderURL;
121
122 QNetworkRequest activeRequest = QNetworkRequest(QUrl(aCameraDataRemoteFolderURL));
123 activeDialog->setRequest(&activeRequest);
124 activeDialog->setReply(activeDialog->getANetworkAccessManager()->get(activeRequest));
125
126 QNetworkReply *activeReply = activeDialog->getReply();
127 QTimer::singleShot(60000, activeReply, [activeReply] //Time-out is 60 seconds
128 {
129 activeReply->abort();
130 activeReply->deleteLater();
131 qCCritical(KSTARS_EKOS_CAPTURE) << "CameraDataFile Download Timed out.";
132 });
133
134 QVector<QString> *availableCameraDataFiles = new QVector<QString>();
135
136 activeDialog->connect(activeReply, &QNetworkReply::finished,
137 activeDialog,
138 [availableCameraDataFiles, activeReply, activeDialog]
139 {
140 // qCInfo(KSTARS_EKOS_CAPTURE) << "The Camera Data File List download is finished";
141 activeReply->deleteLater();
142 if (activeReply->error() != QNetworkReply::NoError)
143 {
144 qCCritical(KSTARS_EKOS_CAPTURE) << "An error occurred in the Camera Data File List download";
145 return;
146 }
147
148 // Parse out the filenames from the tree
149 std::string responseDataStr = activeReply->readAll().toStdString();
150
151 // qCInfo(KSTARS_EKOS_CAPTURE) << "Camera Data File Github Tree:\n" << QString::fromStdString(responseDataStr);
152
153 std::string startdelimiter = "[";
154 std::string stopdelimiter = "]";
155 std::string treeStr = responseDataStr.substr(responseDataStr.find(startdelimiter) + 1, responseDataStr.find(stopdelimiter) - responseDataStr.find(startdelimiter));
156
157 std::vector <std::string> tokens;
158 std::stringstream responseDataStream(treeStr);
159
160 std::string intermediate;
161
162 while(getline(responseDataStream, intermediate, ','))
163 {
164 tokens.push_back(intermediate);
165 }
166
167 // Find the camera file name
168 for(int i = 0; i < tokens.size(); i++)
169 {
170 if(tokens[i].find("path") != std::string::npos)
171 {
172
173 std::string aCameraDataFileStr = tokens[i].substr(9, tokens[i].length() - 14);
174 // std::cout << aCameraDataFileStr << '\n';
175
176 QString aCameraDataFile = QString::fromStdString(aCameraDataFileStr);
177
178 availableCameraDataFiles->append(aCameraDataFile);
179
180 }
181 }
182 activeDialog->setAvailableCameraDataFiles(*availableCameraDataFiles);
183 activeDialog->refreshCameraList();
184 });
185
186 activeDialog->connect(activeReply, &QNetworkReply::downloadProgress,
187 activeDialog,
188 [availableCameraDataFiles, activeReply, activeDialog]
189 {
190 qCInfo(KSTARS_EKOS_CAPTURE) << "The Camera Data File List download is in progress";
191 });
192 activeDialog->connect(activeReply, &QNetworkReply::errorOccurred,
193 activeDialog,
194 [availableCameraDataFiles, activeReply, activeDialog]
195 {
196 qCCritical(KSTARS_EKOS_CAPTURE) << "The Camera Data File List download had an error";
197 });
198 activeDialog->connect(activeReply, &QNetworkReply::destroyed,
199 activeDialog,
200 [availableCameraDataFiles, activeReply, activeDialog]
201 {
202 qCInfo(KSTARS_EKOS_CAPTURE) << "The Camera Data File List connection was destroyed";
203 });
204
205 qCInfo(KSTARS_EKOS_CAPTURE) << "The Camera Data File List length is " << availableCameraDataFiles->length();
206
207
208}
209
210void OptimalExposure::FileUtilityCameraData::downloadCameraDataFile(
211 QString cameraId,
212 QDialog *aDialog)
213{
214
215 FileUtilityCameraDataDialog *activeDialog = static_cast<FileUtilityCameraDataDialog *> (aDialog);
216
217 activeDialog->setANetworkAccessManager(new QNetworkAccessManager(activeDialog));
218
219 QDir filePath = OptimalExposure::FileUtilityCameraData::cameraLocalDataRepository;
220 filePath.mkpath(".");
221
222 QString cameraDataFileName = cameraIdToCameraDataFileName(cameraId);
223
224 // File in remote repository
225 QString aCameraDataDownloadURL = OptimalExposure::FileUtilityCameraData::cameraDataRemoteRepository
226 + cameraDataFileName;
227
228 // File for local storage
229 QString aCameraDataLocalFileName = OptimalExposure::FileUtilityCameraData::cameraLocalDataRepository
230 + cameraDataFileName;
231
232 //QString aCameraDataLocalFileName = KSPaths::locate(QStandardPaths::AppLocalDataLocation,
233 // QString("cameradata/%1").arg(cameraDataFileName));
234
235
236
237 qCInfo(KSTARS_EKOS_CAPTURE) << "Attempting Download Camera Data from "
238 << aCameraDataDownloadURL << "\n\tto " << aCameraDataLocalFileName;
239
240 QNetworkRequest activeRequest = QNetworkRequest(QUrl(aCameraDataDownloadURL));
241 activeDialog->setRequest(&activeRequest);
242
243 activeDialog->setReply(activeDialog->getANetworkAccessManager()->get(activeRequest));
244 QNetworkReply *activeReply = activeDialog->getReply();
245 QTimer::singleShot(60000, activeReply, [activeReply] //Time-out is 60 seconds
246 {
247 activeReply->abort();
248 activeReply->deleteLater();
249 qCCritical(KSTARS_EKOS_CAPTURE) << Q_FUNC_INFO << "CameraDataFile Download Timed out.";
250 });
251 activeDialog->connect(activeReply, &QNetworkReply::finished,
252 activeDialog,
253 [aCameraDataLocalFileName, activeReply, activeDialog]
254 {
255 activeReply->deleteLater();
256 if (activeReply->error() != QNetworkReply::NoError)
257 {
258 qCCritical(KSTARS_EKOS_CAPTURE)
259 << "An error occurred in the Camera Data File download of "
260 << aCameraDataLocalFileName;
261 return;
262 }
263 QFile aCameraDataFile(aCameraDataLocalFileName);
264 if(aCameraDataFile.open(QIODevice::ReadWrite | QIODevice::Truncate))
265 {
266 QByteArray responseData = activeReply->readAll();
267 if (aCameraDataFile.write(responseData))
268 {
269 aCameraDataFile.close();
270 qCInfo(KSTARS_EKOS_CAPTURE) << "The Camera Data File download of "
271 << aCameraDataLocalFileName << " is finished";
272 activeDialog->decrementDownloadFileCounter();
273 }
274 else
275 {
276 qCCritical(KSTARS_EKOS_CAPTURE) << "The Camera Data File download of "
277 << aCameraDataLocalFileName << " was not completed";
278 }
279 }
280 });
281 activeDialog->connect(activeReply, &QNetworkReply::downloadProgress,
282 activeDialog,
283 [aCameraDataLocalFileName, activeReply, activeDialog]
284 {
285 qCInfo(KSTARS_EKOS_CAPTURE) << "The Camera Data File download of "
286 << aCameraDataLocalFileName << " is in progress";
287 });
288 activeDialog->connect(activeReply, &QNetworkReply::errorOccurred,
289 activeDialog,
290 [aCameraDataLocalFileName, activeReply, activeDialog]
291 {
292 qCInfo(KSTARS_EKOS_CAPTURE) << "The Camera Data File download of "
293 << aCameraDataLocalFileName << " had an error";
294 });
295 activeDialog->connect(activeReply, &QNetworkReply::destroyed,
296 activeDialog,
297 [aCameraDataLocalFileName, activeReply, activeDialog]
298 {
299 qCInfo(KSTARS_EKOS_CAPTURE) << "The Camera Data File connection for " << aCameraDataLocalFileName << " was destroyed";
300 });
301
302}
303
304
305int OptimalExposure::FileUtilityCameraData::readCameraDataFile(QString aCameraDataFile,
306 OptimalExposure::ImagingCameraData *anImagingCameraData)
307{
308 // QString aCameraDataFile = OptimalExposure::FileUtilityCameraData::cameraApplicationDataRepository +
309 // cameraIdToCameraDataFileName(cameraId);
310
311 // qCInfo(KSTARS_EKOS_CAPTURE) << "Opening... " + aCameraDataFile;
312
313 QFile file(aCameraDataFile);
314 if(file.open(QIODevice::ReadOnly | QIODevice::Text))
315 {
316 // qCInfo(KSTARS_EKOS_CAPTURE) << "Reading... " + aCameraDataFile;
317 QXmlStreamReader xmlReader(&file);
318
319 if (xmlReader.readNextStartElement())
320 {
321 // qCInfo(KSTARS_EKOS_CAPTURE) << "xmlReader start element name: " << xmlReader.name();
322 if (xmlReader.name() == "ExposureCalculatorCameraData")
323 {
324 // qCInfo(KSTARS_EKOS_CAPTURE) << "Found aCamera Element...";
325
326 QVector<OptimalExposure::CameraGainReadMode> *aCameraGainReadModeVector
327 = new QVector<OptimalExposure::CameraGainReadMode>();
328
329 while(xmlReader.readNextStartElement())
330 {
331 // qCInfo(KSTARS_EKOS_CAPTURE) << "xmlReader start element name: " << xmlReader.name();
332 if (xmlReader.name() == "CameraDataClassVersion")
333 {
334 int aDataClassVersion = xmlReader.readElementText().toInt();
335 anImagingCameraData->setDataClassVersion(aDataClassVersion);
336 }
337
338 if (xmlReader.name() == "CameraId")
339 {
340 // qCInfo(KSTARS_EKOS_CAPTURE) << "Found aCameraId Element...";
341 QString aCameraIdString = xmlReader.readElementText();
342 // qCInfo(KSTARS_EKOS_CAPTURE) << "Read element text..." + aCameraIdString;
343 anImagingCameraData->setCameraId(aCameraIdString);
344 }
345
346 if (xmlReader.name() == "SensorType")
347 {
348 // qCInfo(KSTARS_EKOS_CAPTURE) << "Found SensorType Element...";
349 QString aSensorType = xmlReader.readElementText();
350 // qCInfo(KSTARS_EKOS_CAPTURE) << "Read element text..." + aSensorType;
351 if(aSensorType == "COLOR")
352 anImagingCameraData->setSensorType(OptimalExposure::SENSORTYPE_COLOR);
353
354 if(aSensorType == "MONOCHROME")
355 anImagingCameraData->setSensorType(OptimalExposure::SENSORTYPE_MONOCHROME);
356 }
357
358 if (xmlReader.name() == "GainSelectionType")
359 {
360 // qCInfo(KSTARS_EKOS_CAPTURE) << "Found GainSelectionType Element...";
361 QString aGainSelectionType = xmlReader.readElementText();
362 // qCInfo(KSTARS_EKOS_CAPTURE) << "Read element text..." + aGainSelectionType;
363 if(aGainSelectionType == "NORMAL")
364 anImagingCameraData->setGainSelectionType(OptimalExposure::GAIN_SELECTION_TYPE_NORMAL);
365 if(aGainSelectionType == "ISO_DISCRETE")
366 anImagingCameraData->setGainSelectionType(OptimalExposure::GAIN_SELECTION_TYPE_ISO_DISCRETE);
367 if(aGainSelectionType == "FIXED")
368 anImagingCameraData->setGainSelectionType(OptimalExposure::GAIN_SELECTION_TYPE_FIXED);
369 }
370
371
372 // GainSelection collection // For GAIN_SELECTION_TYPE_NORMAL the collection represents min and max,
373 // for GAIN_SELECTION_TYPE_ISO_DISCRETE, the collection is the discrete list of of gain/iso values.
374 // Note that the data available for GainReadNoiseValue may not match a camera discrete gain/iso values,
375 // so this collection resolves that.
376
377 if (xmlReader.name() == "CameraGainSelections")
378 {
379 QVector<int> *aGainSelectionVector = new QVector<int>();
380
381 int aGainSelection = 0;
382 while(xmlReader.readNext() && !(xmlReader.name() == "CameraGainSelections" && xmlReader.isEndElement()))
383 {
384 // qCInfo(KSTARS_EKOS_CAPTURE) << "xmlReader.name() = " << xmlReader.name();
385 if (xmlReader.name() == "GainSelection")
386 {
387 // qCInfo(KSTARS_EKOS_CAPTURE) << "xmlReader.name() = " << xmlReader.name();
388 QString aGainSelectionString = xmlReader.readElementText();
389 aGainSelection = aGainSelectionString.toInt();
390 // qCInfo(KSTARS_EKOS_CAPTURE) << "a Found GainSelection text: " << aGainSelection;
391
392 // qCInfo(KSTARS_EKOS_CAPTURE) << "Adding GainSelection to Vector " << QString::number(aGainSelection);
393
394 aGainSelectionVector->push_back(aGainSelection);
395 }
396 }
397 anImagingCameraData->setGainSelectionRange(*aGainSelectionVector);
398 }
399
400 if (xmlReader.name() == "CameraGainReadMode")
401 {
402 OptimalExposure::CameraGainReadMode *aCameraGainReadMode = new OptimalExposure::CameraGainReadMode();
403
404 while(xmlReader.readNext() && !(xmlReader.name() == "CameraGainReadMode" && xmlReader.isEndElement()))
405 {
406 // qCInfo(KSTARS_EKOS_CAPTURE) << "xmlReader.name() = " << xmlReader.name();
407 if (xmlReader.name() == "GainReadModeNumber")
408 {
409 QString aGainReadModeNumberString = xmlReader.readElementText();
410 aCameraGainReadMode->setCameraGainReadModeNumber(aGainReadModeNumberString.toInt());
411 }
412 if (xmlReader.name() == "GainReadModeName")
413 {
414 aCameraGainReadMode->setCameraGainReadModeName(xmlReader.readElementText());
415 }
416
417 // CameraGainReadNoise collection
418 if (xmlReader.name() == "CameraGainReadNoise")
419 {
420 // qCInfo(KSTARS_EKOS_CAPTURE) << "Found CameraGainReadNoise Element...";
421 // QString aCameraGainReadNoise = xmlReader.readElementText();
422 // // qCInfo(KSTARS_EKOS_CAPTURE) << "Read element ..." + aCameraGainReadNoise;
423
424 QVector<OptimalExposure::CameraGainReadNoise> *aCameraGainReadNoiseVector
425 = new QVector<OptimalExposure::CameraGainReadNoise>();
426
427
428 // Iterate for Gain Read-Noise data
429 int aGain = 0;
430 double aReadNoise = 0.0;
431 while(xmlReader.readNext() && !(xmlReader.name() == "CameraGainReadNoise" && xmlReader.isEndElement()) )
432 {
433 // qCInfo(KSTARS_EKOS_CAPTURE) << "xmlReader.name() = " << xmlReader.name();
434
435 if (xmlReader.isEndElement())
436 // qCInfo(KSTARS_EKOS_CAPTURE) << "At end of = " << xmlReader.name();
437
438
439 if (xmlReader.name() == "GainReadNoiseValue")
440 {
441 // qCInfo(KSTARS_EKOS_CAPTURE) << "Found GainReadNoiseValue Element...";
442 }
443
444 if (xmlReader.name() == "Gain")
445 {
446 // qCInfo(KSTARS_EKOS_CAPTURE) << "Found Gain Element...";
447 QString aGainString = xmlReader.readElementText();
448 aGain = aGainString.toInt();
449 // qCInfo(KSTARS_EKOS_CAPTURE) << "a Found Gain text: " << aGain;
450 }
451
452 if (xmlReader.name() == "ReadNoise")
453 {
454 // qCInfo(KSTARS_EKOS_CAPTURE) << "Found ReadNoise Element...";
455 QString aReadNoiseString = xmlReader.readElementText();
456 aReadNoise = aReadNoiseString.toDouble();
457 // qCInfo(KSTARS_EKOS_CAPTURE) << "a Found ReadNoise text: " << aReadNoise;
458
459 // Add this to a vector
460 // qCInfo(KSTARS_EKOS_CAPTURE) << "Adding Gain Read-Noise to Vector " << QString::number(aGain) << " " << QString::number(aReadNoise) ;
461 aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(aGain, aReadNoise)));
462 }
463 }
464 aCameraGainReadMode->setCameraGainReadNoiseVector(*aCameraGainReadNoiseVector);
465 aCameraGainReadModeVector->push_back(*aCameraGainReadMode);
466 }
467 anImagingCameraData->setCameraGainReadModeVector(*aCameraGainReadModeVector);
468 }
469 // qCInfo(KSTARS_EKOS_CAPTURE) << "Finished reading mode ";
470 }
471
472 }
473 // qCInfo(KSTARS_EKOS_CAPTURE) << "Read xml data for " + anImagingCameraData->getCameraId();
474
475 }
476 else
477 {
478 qCCritical(KSTARS_EKOS_CAPTURE) << "Read Failed";
479 xmlReader.raiseError(QObject::tr("Incorrect file"));
480 }
481 }
482 else
483 {
484 qCCritical(KSTARS_EKOS_CAPTURE) << "Read Initial Element Failed,";
485 }
486 }
487 else
488 {
489 qCCritical(KSTARS_EKOS_CAPTURE)
490 << "Cannot open file for reading " << file.errorString();
491 }
492
493 file.close();
494 return 0;
495}
496
497int OptimalExposure::FileUtilityCameraData::writeCameraDataFile(OptimalExposure::ImagingCameraData *anImagingCameraData)
498{
499
500 if(QDir().mkpath(cameraLocalDataRepository))
501 {
502 // Replace spaces with "_" in the file name
503 QString aCameraDataFile = cameraLocalDataRepository + cameraIdToCameraDataFileName(anImagingCameraData->getCameraId());
504
505 QFile file(aCameraDataFile);
506 if(file.open(QIODevice::ReadWrite | QIODevice::Truncate | QIODevice::Text))
507 {
508
509 QXmlStreamWriter xmlWriter(&file);
510 xmlWriter.setAutoFormatting(true);
511 xmlWriter.writeStartDocument();
512
513 xmlWriter.writeStartElement("ExposureCalculatorCameraData");
514
515 xmlWriter.writeTextElement("CameraDataClassVersion", QString::number(anImagingCameraData->getDataClassVersion()));
516
517 xmlWriter.writeTextElement("CameraId", anImagingCameraData->getCameraId() );
518
519 switch(anImagingCameraData->getSensorType())
520 {
521 case OptimalExposure::SENSORTYPE_MONOCHROME:
522 xmlWriter.writeTextElement("SensorType", QString("MONOCHROME"));
523 break;
524 case OptimalExposure::SENSORTYPE_COLOR:
525 xmlWriter.writeTextElement("SensorType", QString("COLOR"));
526 break;
527 }
528
529 switch(anImagingCameraData->getGainSelectionType())
530 {
531 case OptimalExposure::GAIN_SELECTION_TYPE_NORMAL:
532 xmlWriter.writeTextElement("GainSelectionType", QString("NORMAL"));
533 break;
534 case OptimalExposure::GAIN_SELECTION_TYPE_ISO_DISCRETE:
535 xmlWriter.writeTextElement("GainSelectionType", QString("ISO_DISCRETE"));
536 break;
537 case OptimalExposure::GAIN_SELECTION_TYPE_FIXED:
538 xmlWriter.writeTextElement("GainSelectionType", QString("FIXED"));
539 break;
540 }
541
542 xmlWriter.writeStartElement("CameraGainSelections");
543 QVector<int> aGainSelectionRange = anImagingCameraData->getGainSelectionRange();
544 for(int gs = 0; gs < aGainSelectionRange.count(); gs++)
545 {
546 // xmlWriter.writeStartElement("GainSelection");
547 xmlWriter.writeTextElement("GainSelection", QString::number(anImagingCameraData->getGainSelectionRange()[gs]));
548 // xmlWriter.writeEndElement();
549 }
550 xmlWriter.writeEndElement();
551
552 // Iterate through values of anImagingCameraData->CameraGainReadModeVector
553
554 xmlWriter.writeStartElement("CameraGainReadMode");
555 QVector<OptimalExposure::CameraGainReadMode> aCameraGainReadModeVector =
556 anImagingCameraData->getCameraGainReadModeVector();
557 for(QVector<OptimalExposure::CameraGainReadMode>::iterator readMode = aCameraGainReadModeVector.begin();
558 readMode != aCameraGainReadModeVector.end(); ++readMode)
559 {
560 xmlWriter.writeTextElement("GainReadModeNumber", QString::number(readMode->getCameraGainReadModeNumber()));
561 xmlWriter.writeTextElement("GainReadModeName", readMode->getCameraGainReadModeName());
562 // xmlWriter.writeStartElement("GainReadModeNumber");
563 // xmlWriter.writeEndElement();
564 // xmlWriter.writeStartElement("GainReadModeName");
565 // xmlWriter.writeEndElement();
566 // Iterate through values of readMode->CameraGainReadNoiseVector
567 xmlWriter.writeStartElement("CameraGainReadNoise");
568 QVector<OptimalExposure::CameraGainReadNoise> aCameraGainReadNoiseVector =
569 readMode->getCameraGainReadNoiseVector();
570
571 for(QVector<OptimalExposure::CameraGainReadNoise>::iterator readNoisePair = aCameraGainReadNoiseVector.begin();
572 readNoisePair != aCameraGainReadNoiseVector.end(); ++readNoisePair)
573 {
574 xmlWriter.writeStartElement("GainReadNoiseValue");
575 xmlWriter.writeTextElement("Gain", QString::number(readNoisePair->getGain()));
576 xmlWriter.writeTextElement("ReadNoise", QString::number(readNoisePair->getReadNoise()));
577 xmlWriter.writeEndElement();
578 }
579 xmlWriter.writeEndElement();
580
581 }
582 xmlWriter.writeEndElement();
583 xmlWriter.writeEndElement();
584 xmlWriter.writeEndDocument();
585 file.close();
586
587 }
588 else
589 {
590 qCCritical(KSTARS_EKOS_CAPTURE)
591 << "Cannot open camera data file for writing " << file.errorString();
592 }
593 }
594 return 0;
595
596
597}
598
599
600// Make example camera data files
601//void OptimalExposure::FileUtilityCameraData::buildCameraDataFile()
602//{
603// /*
604// * camera naming should try match the Camera device name (cameraId) present in KStars.
605// * A cameraId in KStars appears to consist of a device label (or driver id) and the camera model.
606// *
607// * For example:
608// * a "ZWO ASI-071 MC Pro"
609// *
610// * The usb id is "ZWO ASI071MC Pro", but KStars uses a driver prefix ("ZWO CCD") in the cameraId.
611// * cameraId = "ZWO CCD ASI071MC Pro";
612// *
613// * The file utility code will replace spaces with underscore on writes, and vice-versa on reads.
614// * So the xml file would be "ZWO_CCD_ASI071MC_Pro.xml"
615// *
616// * But for many of these examples the kstars cameraId was not available (I do not own all these cameras).
617// * So guesses were made for the cameraId of most of these cameras.
618// *
619// *
620// *
621// * Manufacturers:
622// cat indidrivers.xml | grep -i driver | grep -i ccd
623// <driver name="CCD Simulator">indi_simulator_ccd</driver>
624// <driver name="V4L2 CCD">indi_v4l2_ccd</driver>
625// <driver name="Apogee CCD">indi_apogee_ccd</driver>
626// <driver name="ZWO CCD">indi_asi_ccd</driver>
627// <driver name="ZWO Camera">indi_asi_single_ccd</driver>
628// <driver name="Atik">indi_atik_ccd</driver>
629// <driver name="Cam90 CCD">indi_cam90_ccd</driver>
630// <driver name="DSI">indi_dsi_ccd</driver>
631// <driver name="FireFly MV">indi_ffmv_ccd</driver>
632// <driver name="Starfish CCD">indi_fishcamp_ccd</driver>
633// <driver name="FLI Kepler">indi_kepler_ccd</driver>
634// <driver name="FLI CCD">indi_fli_ccd</driver>
635// <driver name="Canon DSLR">indi_canon_ccd</driver>
636// <driver name="Nikon DSLR">indi_nikon_ccd</driver>
637// <driver name="Pentax DSLR">indi_pentax_ccd</driver>
638// <driver name="Sony DSLR">indi_sony_ccd</driver>
639// <driver name="Fuji DSLR">indi_fuji_ccd</driver>
640// <driver name="GPhoto CCD">indi_gphoto_ccd</driver>
641// <driver name="iNova PLX">indi_inovaplx_ccd</driver>
642// <driver name="MI CCD">indi_mi_ccd_usb</driver>
643// <driver name="MI CCD">indi_mi_ccd_eth</driver>
644// <driver name="Nightscape CCD">indi_nightscape_ccd</driver>
645// <driver name="Orion SSG3">indi_orion_ssg3_ccd</driver>
646// <driver name="PlayerOne CCD">indi_playerone_ccd</driver>
647// <driver name="QHY CCD">indi_qhy_ccd</driver>
648// <driver name="QSI CCD">indi_qsi_ccd</driver>
649// <driver name="SBIG CCD">indi_sbig_ccd</driver>
650// <driver name="SBIG CCD">indi_sbig_ccd</driver>
651// <driver name="SVBONY CCD">indi_svbony_ccd</driver>
652// <driver name="SX CCD">indi_sx_ccd</driver>
653// <driver name="Toupcam">indi_toupcam_ccd</driver>
654// <driver name="Altair">indi_altair_ccd</driver>
655// <driver name="Bressercam">indi_bressercam_ccd</driver>
656// <driver name="Mallincam">indi_mallincam_ccd</driver>
657// <driver name="Nncam">indi_nncam_ccd</driver>
658// <driver name="Ogmacam">indi_ogmacam_ccd</driver>
659// <driver name="OmegonPro">indi_omegonprocam_ccd</driver>
660// <driver name="StartshootG">indi_starshootg_ccd</driver>
661// <driver name="Tscam">indi_tscam_ccd</driver>
662// <driver name="Nncam">indi_nncam_ccd</driver>
663// <driver name="INDI Webcam">indi_webcam_ccd</driver>
664
665// grep -iR "device label" | grep -i " CCD"
666// indidrivers.xml: <device label="DMK CCD" manufacturer="DMK">
667// indidrivers.xml: <device label="V4L2 CCD" manufacturer="Web Cameras">
668// indidrivers.xml: <device label="Apogee CCD" manufacturer="Andor">
669// indidrivers.xml: <device label="ZWO CCD" mdpd="true" manufacturer="ZWO">
670// indidrivers.xml: <device label="Atik CCD" mdpd="true" manufacturer="Atik">
671// indidrivers.xml: <device label="Cam90 CCD" mdpd="true">
672// indidrivers.xml: <device label="Starfish CCD">
673// indidrivers.xml: <device label="FLI CCD" manufacturer="Finger Lakes Instruments">
674// indidrivers.xml: <device label="GPhoto CCD" manufacturer="DSLRs">
675// indidrivers.xml: <device label="MI CCD (USB)" manufacturer="Moravian Instruments">
676// indidrivers.xml: <device label="MI CCD (ETH)" manufacturer="Moravian Instruments">
677// indidrivers.xml: <device label="Nightscape 8300 CCD" mdpd="true" manufacturer="Celestron">
678// indidrivers.xml: <device label="PlayerOne CCD" mdpd="true" manufacturer="PlayerOne">
679// indidrivers.xml: <device label="QHY CCD" mdpd="true" manufacturer="QHY">
680// indidrivers.xml: <device label="QSI CCD" manufacturer="QSI">
681// indidrivers.xml: <device label="SBIG CCD" manufacturer="Diffraction Limited">
682// indidrivers.xml: <device label="SVBONY CCD" mdpd="true" manufacturer="SVBONY">
683// indidrivers.xml: <device label="SX CCD" mdpd="true" manufacturer="Starlight XPress">
684
685// */
686
687// // Define and re-use for each camera instance
688// QString cameraId;
689// int readModeNumber = 0;
690// QString readModeName;
691// QVector<OptimalExposure::CameraGainReadNoise> *aCameraGainReadNoiseVector;
692// QVector<OptimalExposure::CameraGainReadMode> *aCameraGainReadModeVector;
693
694// QVector<int> *gainSelection;
695// OptimalExposure::ImagingCameraData *anImagingCameraData;
696
697// // This QHY camera has selectable read modes, with distinct read-noise data.
698// // The indi driver may provide a "Read Mode" selectoin on the indi panel.
699// // The xml data files are revised to handle multiple read-modes for a camera
700// // in a single file.
701
702// // #0 Photographic, #1 High Gain, #2 Extended Full Well and #3 Extended Full Well 2CMSIT.
703
704// // Research: Is the same read-noise is used in both Mono and Color versions?
705
706// cameraId = "QHY CCD 268M";
707// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
708
709// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
710// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 7.25)));
711// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(5, 7.1)));
712// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(10, 6.78)));
713// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(15, 6.74)));
714// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(20, 6.74)));
715// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(25, 2.8)));
716// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(30, 2.63)));
717// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(35, 2.7)));
718// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(40, 2.57)));
719// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(45, 2.55)));
720// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(50, 2.52)));
721// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(55, 2.35)));
722// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(60, 2.07)));
723// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(65, 2.05)));
724// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(70, 2.04)));
725// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(75, 2.06)));
726// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(80, 2.03)));
727// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(85, 2.01)));
728// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(90, 2)));
729// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(95, 1.99)));
730// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 2)));
731// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(105, 1.97)));
732// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(110, 1.96)));
733// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(115, 1.95)));
734// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(120, 1.94)));
735// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(125, 1.93)));
736// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(130, 1.92)));
737// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(135, 1.89)));
738// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(140, 1.9)));
739// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(145, 1.89)));
740// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(150, 1.85)));
741// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(155, 1.82)));
742// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(160, 1.81)));
743// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(165, 1.8)));
744// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(170, 1.79)));
745// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(175, 1.75)));
746// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(180, 1.74)));
747// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(185, 1.7)));
748// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(190, 1.68)));
749// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(195, 1.67)));
750// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 1.62)));
751// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(205, 1.59)));
752// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(210, 1.56)));
753// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(215, 1.53)));
754// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(220, 1.48)));
755// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(225, 1.44)));
756// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(230, 1.41)));
757// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(235, 1.36)));
758// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(240, 1.32)));
759// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(245, 1.26)));
760// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(250, 1.17)));
761// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(255, 1.12)));
762// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(260, 1.03)));
763// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(265, 0.92)));
764// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(270, 0.79)));
765// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(275, 0.62)));
766// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(280, 0.6)));
767// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(285, 0.7)));
768
769// readModeNumber = 0;
770// readModeName = "Photographic";
771
772// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
773// *aCameraGainReadNoiseVector)));
774
775// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
776
777// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(5, 3.6)));
778// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(10, 3.58)));
779// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(15, 3.64)));
780// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(20, 3.63)));
781// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(25, 3.63)));
782// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(30, 3.58)));
783// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(35, 3.49)));
784// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(40, 3.39)));
785// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(45, 3.43)));
786// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(50, 3.53)));
787// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(55, 3.43)));
788// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(60, 1.69)));
789// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(65, 1.69)));
790// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(70, 1.67)));
791// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(75, 1.67)));
792// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(80, 1.63)));
793// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(85, 1.6)));
794// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(90, 1.57)));
795// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(95, 1.53)));
796// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 1.25)));
797// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(105, 1.22)));
798// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(110, 1.22)));
799// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(115, 1.21)));
800// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(120, 1.2)));
801// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(125, 1.2)));
802// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(130, 1.19)));
803// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(135, 1.18)));
804// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(140, 1.17)));
805// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(145, 1.15)));
806// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(150, 1.14)));
807// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(155, 1.14)));
808// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(160, 1.13)));
809// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(165, 1.12)));
810// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(170, 1.11)));
811// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(175, 1.09)));
812// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(180, 1.09)));
813// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(185, 1.08)));
814// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(190, 1.06)));
815// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(195, 1.06)));
816// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 1.03)));
817// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(205, 1.01)));
818// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(210, 0.98)));
819// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(215, 0.99)));
820// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(220, 0.96)));
821// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(225, 0.97)));
822// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(230, 0.92)));
823// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(235, 0.93)));
824// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(240, 0.87)));
825// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(245, 0.87)));
826// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(250, 0.8)));
827// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(255, 0.79)));
828// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(260, 0.8)));
829// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(265, 0.7)));
830// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(270, 0.71)));
831// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(275, 0.7)));
832// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(280, 0.69)));
833// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(285, 0.69)));
834
835// readModeNumber = 1;
836// readModeName = "High Gain";
837
838// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
839// *aCameraGainReadNoiseVector)));
840
841// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
842// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 7.56)));
843// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(5, 7.48)));
844// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(10, 7.41)));
845// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(15, 7.34)));
846// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(20, 7.22)));
847// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(25, 7.15)));
848// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(30, 7.01)));
849// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(35, 6.83)));
850// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(40, 6.69)));
851// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(45, 6.6)));
852// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(50, 6.64)));
853// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(55, 6.72)));
854// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(60, 6.86)));
855// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(65, 6.93)));
856// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(70, 6.73)));
857// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(75, 6.44)));
858// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(80, 6.55)));
859// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(85, 6.06)));
860// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(90, 6.16)));
861// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(95, 5.75)));
862// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 5.36)));
863// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(105, 5.34)));
864// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(110, 5.34)));
865// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(115, 5.35)));
866// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(120, 5.34)));
867// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(125, 5.3)));
868// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(130, 5.22)));
869// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(135, 5.18)));
870// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(140, 5.09)));
871// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(145, 5.04)));
872// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(150, 4.96)));
873// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(155, 4.9)));
874// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(160, 4.85)));
875// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(165, 4.77)));
876// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(170, 4.71)));
877// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(175, 4.62)));
878// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(180, 4.57)));
879// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(185, 4.46)));
880// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(190, 4.4)));
881// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(195, 4.32)));
882// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 4.2)));
883// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(205, 4.1)));
884// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(210, 4.02)));
885// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(215, 3.95)));
886// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(220, 3.79)));
887// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(225, 3.71)));
888// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(230, 3.58)));
889// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(235, 3.53)));
890// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(240, 3.41)));
891// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(245, 3.26)));
892// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(250, 3.14)));
893// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(255, 3.04)));
894// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(260, 2.87)));
895// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(265, 2.8)));
896// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(270, 2.62)));
897// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(275, 2.5)));
898// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(280, 2.34)));
899// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(285, 2.18)));
900
901// readModeNumber = 2;
902// readModeName = "Extended Full Well";
903
904// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
905// *aCameraGainReadNoiseVector)));
906
907// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
908// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 5.89)));
909// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(5, 5.82)));
910// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(10, 5.82)));
911// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(15, 5.73)));
912// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(20, 5.66)));
913// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(25, 5.58)));
914// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(30, 5.44)));
915// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(35, 5.39)));
916// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(40, 5.26)));
917// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(45, 5.17)));
918// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(50, 5.17)));
919// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(55, 5.25)));
920// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(60, 5.34)));
921// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(65, 5.43)));
922// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(70, 5.33)));
923// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(75, 5.08)));
924// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(80, 5.05)));
925// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(85, 4.81)));
926// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(90, 4.85)));
927// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(95, 4.55)));
928// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 4.26)));
929// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(105, 4.25)));
930// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(110, 4.23)));
931// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(115, 4.26)));
932// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(120, 4.26)));
933// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(125, 4.23)));
934// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(130, 4.18)));
935// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(135, 4.15)));
936// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(140, 4.08)));
937// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(145, 4.09)));
938// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(150, 4.05)));
939// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(155, 4.01)));
940// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(160, 3.98)));
941// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(165, 3.96)));
942// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(170, 3.91)));
943// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(175, 3.87)));
944// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(180, 3.83)));
945// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(185, 3.8)));
946// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(190, 3.76)));
947// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(195, 3.68)));
948// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 3.64)));
949// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(205, 3.57)));
950// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(210, 3.51)));
951// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(215, 3.44)));
952// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(220, 3.39)));
953// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(225, 3.33)));
954// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(230, 3.25)));
955// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(235, 3.2)));
956// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(240, 3.13)));
957// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(245, 3.03)));
958// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(250, 2.99)));
959// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(255, 2.87)));
960// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(260, 2.77)));
961// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(265, 2.72)));
962// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(270, 2.58)));
963// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(275, 2.5)));
964// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(280, 2.37)));
965// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(285, 2.22)));
966
967// readModeNumber = 3;
968// readModeName = "Extended Full Well 2CMSIT";
969// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
970// *aCameraGainReadNoiseVector)));
971
972// gainSelection = new QVector<int>( { 0, 285 } );
973// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_MONOCHROME,
974// OptimalExposure::GAIN_SELECTION_TYPE_NORMAL, *gainSelection, *aCameraGainReadModeVector);
975// anImagingCameraData->setDataClassVersion(1);
976// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
977
978// cameraId = "ZWO CCD ASI071MC Pro";
979// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
980// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 3.28)));
981// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(50, 2.78)));
982// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 2.58)));
983// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(150, 2.39)));
984// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 2.29)));
985// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(250, 2.27)));
986
987// readModeNumber = 0;
988// readModeName = "Standard";
989// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
990// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
991// *aCameraGainReadNoiseVector)));
992
993// gainSelection = new QVector<int>( { 0, 250 } );
994// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_COLOR,
995// OptimalExposure::GAIN_SELECTION_TYPE_NORMAL, *gainSelection, *aCameraGainReadModeVector);
996
997// anImagingCameraData->setDataClassVersion(1);
998// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
999
1000
1001
1002
1003// // usb id is "ZWO ASI178MC"
1004// cameraId = "ZWO CCD ASI178MC";
1005// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
1006// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 2.23)));
1007// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(50, 1.92)));
1008// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 1.74)));
1009// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(150, 1.58)));
1010// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 1.45)));
1011// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(250, 1.39)));
1012// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(300, 1.38)));
1013// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(400, 1.35)));
1014
1015// readModeNumber = 0;
1016// readModeName = "Standard";
1017// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
1018// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
1019// *aCameraGainReadNoiseVector)));
1020
1021
1022// gainSelection = new QVector<int>( { 0, 400 } );
1023// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_COLOR,
1024// OptimalExposure::GAIN_SELECTION_TYPE_NORMAL, *gainSelection, *aCameraGainReadModeVector);
1025
1026// anImagingCameraData->setDataClassVersion(1);
1027// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
1028
1029
1030// cameraId = "ZWO CCD ASI6200MM";
1031// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
1032
1033// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 3.6)));
1034// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(50, 3.5)));
1035// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(99, 3.38)));
1036// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 1.55))); // pronounced step
1037// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(150, 1.5)));
1038// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 1.45)));
1039// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(250, 1.42)));
1040// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(300, 1.40)));
1041// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(350, 1.41)));
1042// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(400, 1.32)));
1043// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(450, 1.39)));
1044// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(470, 1.25)));
1045
1046// readModeNumber = 0;
1047// readModeName = "Standard";
1048// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
1049// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
1050// *aCameraGainReadNoiseVector)));
1051
1052// gainSelection = new QVector<int>( { 0, 470 } );
1053
1054// // qCInfo(KSTARS_EKOS_CAPTURE) << "aCameraGainReadNoiseVector size: " << aCameraGainReadNoiseVector->size();
1055// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_MONOCHROME,
1056// OptimalExposure::GAIN_SELECTION_TYPE_NORMAL, *gainSelection, *aCameraGainReadModeVector);
1057// anImagingCameraData->setDataClassVersion(1);
1058// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
1059
1060// cameraId = "ZWO CCD ASI1600MM";
1061// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
1062// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 3.62)));
1063// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(50, 2.5)));
1064// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 1.85)));
1065// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(150, 1.72)));
1066// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 1.40)));
1067// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(250, 1.32)));
1068// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(300, 1.30)));
1069
1070// readModeNumber = 0;
1071// readModeName = "Standard";
1072// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
1073// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
1074// *aCameraGainReadNoiseVector)));
1075
1076
1077// gainSelection = new QVector<int>( { 0, 300 } );
1078// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_MONOCHROME,
1079// OptimalExposure::GAIN_SELECTION_TYPE_NORMAL, *gainSelection, *aCameraGainReadModeVector);
1080// anImagingCameraData->setDataClassVersion(1);
1081// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
1082
1083
1084// cameraId = "ZWO CCD ASI224MC";
1085// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
1086// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 3.09)));
1087// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(20, 2.71)));
1088// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(59, 2.26)));
1089// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(60, 1.6))); // pronounced step
1090// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(70, 1.54)));
1091// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 1.34)));
1092// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(150, 1.14)));
1093// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(250, 0.93)));
1094// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(300, 0.86)));
1095
1096// readModeNumber = 0;
1097// readModeName = "Standard";
1098// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
1099// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
1100// *aCameraGainReadNoiseVector)));
1101
1102
1103// gainSelection = new QVector<int>( { 0, 300 } );
1104// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_COLOR,
1105// OptimalExposure::GAIN_SELECTION_TYPE_NORMAL, *gainSelection, *aCameraGainReadModeVector);
1106// anImagingCameraData->setDataClassVersion(1);
1107// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
1108
1109// cameraId = "ZWO CCD ASI120MC"; // formerly "ZWOASI-120MC" but now assuming a standard naming convention from ZWO
1110// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
1111// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 6.35)));
1112// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(10, 6.41)));
1113// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(15, 6.5)));
1114// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(16, 4.63))); // pronounced step
1115// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(20, 4.67))); // a rise after the step down
1116// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(31, 4.7))); // another step
1117// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(32, 3.87)));
1118// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(47, 3.95))); // rise after the step down
1119// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(48, 3.7)));
1120// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(63, 3.68))); // another step
1121// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(64, 3.54)));
1122// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(75, 3.66))); // rise after a step down
1123// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(87, 3.62)));
1124// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 3.62)));
1125
1126// readModeNumber = 0;
1127// readModeName = "Standard";
1128
1129// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
1130// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
1131// *aCameraGainReadNoiseVector)));
1132
1133
1134// gainSelection = new QVector<int>( { 0, 100 } );
1135// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_COLOR,
1136// OptimalExposure::GAIN_SELECTION_TYPE_NORMAL, *gainSelection, *aCameraGainReadModeVector);
1137// anImagingCameraData->setDataClassVersion(1);
1138// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
1139
1140// cameraId = "ZWO CCD ASI183MC Pro"; // (The same read-noise is used in both Mono and Color)
1141// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
1142// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 3.00)));
1143// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(50, 2.6)));
1144// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 2.22)));
1145// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(150, 2.02)));
1146// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 1.84)));
1147// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(250, 1.75)));
1148// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(270, 1.68)));
1149// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(300, 1.58)));
1150
1151// readModeNumber = 0;
1152// readModeName = "Standard";
1153
1154// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
1155// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
1156// *aCameraGainReadNoiseVector)));
1157
1158
1159// gainSelection = new QVector<int>( { 0, 300 } );
1160// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_COLOR,
1161// OptimalExposure::GAIN_SELECTION_TYPE_NORMAL, *gainSelection, *aCameraGainReadModeVector);
1162// anImagingCameraData->setDataClassVersion(1);
1163// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
1164
1165// cameraId = "ZWO CCD ASI183MM Pro"; // The same read-noise is used in both Mono and Color
1166// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
1167// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 3.00)));
1168// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(50, 2.6)));
1169// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 2.22)));
1170// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(150, 2.02)));
1171// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 1.84)));
1172// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(250, 1.75)));
1173// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(270, 1.68)));
1174// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(300, 1.58)));
1175
1176// readModeNumber = 0;
1177// readModeName = "Standard";
1178
1179// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
1180// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
1181// *aCameraGainReadNoiseVector)));
1182
1183
1184// gainSelection = new QVector<int>( { 0, 300 } );
1185// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_MONOCHROME,
1186// OptimalExposure::GAIN_SELECTION_TYPE_NORMAL, *gainSelection, *aCameraGainReadModeVector);
1187// anImagingCameraData->setDataClassVersion(1);
1188// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
1189
1190
1191
1192// cameraId = "ZWO CCD ASI2600MM Pro"; // formerly "ZWOASI-2600MM" but now assuming a standard naming convention from ZWO
1193// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
1194// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 3.28)));
1195// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(50, 3.06)));
1196// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(99, 2.88)));
1197// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 1.46)));
1198// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(150, 1.42)));
1199// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 1.42)));
1200// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(250, 1.35)));
1201// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(300, 1.35)));
1202// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(350, 1.25)));
1203// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(400, 1.17)));
1204// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(450, 1.11)));
1205// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(460, 1.03)));
1206
1207// readModeNumber = 0;
1208// readModeName = "Standard";
1209// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
1210// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
1211// *aCameraGainReadNoiseVector)));
1212
1213
1214// gainSelection = new QVector<int>( { 0, 460 } );
1215// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_MONOCHROME,
1216// OptimalExposure::GAIN_SELECTION_TYPE_NORMAL, *gainSelection, *aCameraGainReadModeVector);
1217// anImagingCameraData->setDataClassVersion(1);
1218// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
1219
1220
1221
1222// cameraId = "ZWO CCD ASI290MM Mini"; //
1223// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
1224
1225// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 3.23)));
1226// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(50, 2.66)));
1227// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(59, 2.62)));
1228// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(60, 1.66)));
1229// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 1.45)));
1230// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(150, 1.29)));
1231// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 1.13)));
1232// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(250, 1.11)));
1233// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(300, 1.01)));
1234// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(350, 0.96)));
1235
1236// readModeNumber = 0;
1237// readModeName = "Standard";
1238// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
1239// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
1240// *aCameraGainReadNoiseVector)));
1241
1242
1243// gainSelection = new QVector<int>( { 0, 350 } );
1244// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_MONOCHROME,
1245// OptimalExposure::GAIN_SELECTION_TYPE_NORMAL, *gainSelection, *aCameraGainReadModeVector);
1246// anImagingCameraData->setDataClassVersion(1);
1247// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
1248
1249
1250
1251
1252
1253
1254
1255
1256// cameraId = "QHY CCD 533M"; // Assuming the QHY cameraId appear similar to ZWO
1257// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
1258// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 3.34)));
1259// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(5, 3.3)));
1260// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(10, 3.32)));
1261// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(15, 3.4)));
1262// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(20, 3.3)));
1263// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(25, 3.22)));
1264// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(30, 3.19)));
1265// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(35, 3.09)));
1266// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(40, 3.18)));
1267// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(45, 3.12)));
1268// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(50, 3.05)));
1269// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(55, 2.93)));
1270// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(60, 1.66))); // pronounced step
1271// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(65, 1.6)));
1272// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(70, 1.56)));
1273// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(75, 1.54)));
1274// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(80, 1.51)));
1275// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(85, 1.45)));
1276// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(90, 1.4)));
1277// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(95, 1.34)));
1278
1279// readModeNumber = 0;
1280// readModeName = "Standard";
1281
1282// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
1283// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
1284// *aCameraGainReadNoiseVector)));
1285
1286
1287// gainSelection = new QVector<int>( { 0, 95 } );
1288// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_MONOCHROME,
1289// OptimalExposure::GAIN_SELECTION_TYPE_NORMAL, *gainSelection, *aCameraGainReadModeVector);
1290// anImagingCameraData->setDataClassVersion(1);
1291// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
1292
1293
1294
1295// cameraId = "MI CCD C3"; // Not sure how Moravian cameras appear on USB or KStars, need research.
1296// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
1297// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(0, 3.51)));
1298// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(2749, 3.15)));
1299// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(2750, 1.46)));
1300// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(4030, 1.39)));
1301
1302// readModeNumber = 0;
1303// readModeName = "Standard";
1304
1305// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
1306// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
1307// *aCameraGainReadNoiseVector)));
1308
1309// gainSelection = new QVector<int>( { 0, 4030 } );
1310// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_MONOCHROME,
1311// OptimalExposure::GAIN_SELECTION_TYPE_NORMAL, *gainSelection, *aCameraGainReadModeVector);
1312// anImagingCameraData->setDataClassVersion(1);
1313// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
1314
1315
1316// // DSLR Read-noise for ISO values data found at: https://www.photonstophotos.net/Charts/RN_e.htm
1317
1318// // For a Nikon D5000 usb id reads "Nikon Corp. D5000", Kstars shows "Nikon DSLR DSC D5000 (PTP mode)"
1319// cameraId = "Nikon DSLR DSC D5000 (PTP mode)";
1320// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
1321// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 7.727))); // log2 value 2.95
1322// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(126, 7.674))); // log2 value 2.94
1323// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(159, 7.727))); // log2 value 2.95
1324// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 6.320))); // log2 value 2.36)
1325// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(251, 5.134))); // log2 value 2.36)
1326// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(318, 5.169))); // log2 value 2.37
1327// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(400, 4.532))); // log2 value 2.18
1328// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(503, 4.79))); // log2 value 2.26
1329// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(636, 5.169))); // log2 value 2.37
1330// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(800, 4.925))); // log2 value 2.3
1331// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(1006, 4.891))); // log2 value 2.29
1332// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(1273, 4.724))); // log2 value 2.24
1333// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(1600, 4.5))); // log2 value 2.17
1334// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(2011, 4.028))); // log2 value 2.01
1335// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(2546, 3.34))); // log2 value 1.74
1336// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(3200, 2.969))); // log2 value 1.57
1337// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(4022, 2.828))); // log2 value 1.5
1338// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(5091, 2.789))); // log2 value 1.48
1339// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(6400, 2.732))); // log2 value 1.45
1340
1341// readModeNumber = 0;
1342// readModeName = "Standard";
1343// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
1344// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
1345// *aCameraGainReadNoiseVector)));
1346
1347
1348// // Unfortunately this data from www.photonstophotos.net does not align precisely with the discrete values for the ISO in the camera.
1349// // So, the proof of concept code, which needs a list of iso values will use an array from the file.
1350// // The following array would likely come from Ekos with getActiveChip()->getISOList() ?
1351
1352// gainSelection = new QVector<int>( { 100, 125, 160, 250, 320, 400, 500, 640, 800, 1000, 1250, 1600, 2000, 2500, 3200, 4000, 5000, 6400 } );
1353// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_COLOR,
1354// OptimalExposure::GAIN_SELECTION_TYPE_ISO_DISCRETE, *gainSelection, *aCameraGainReadModeVector);
1355// anImagingCameraData->setDataClassVersion(1);
1356// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
1357
1358
1359// // Driver id is "Canon DSLR"
1360// cameraId = "Canon DSLR EOS Ra"; // Not sure how Canon cameras appear on USB, or KStars need research.
1361
1362// aCameraGainReadNoiseVector = new QVector<OptimalExposure::CameraGainReadNoise>();
1363// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(100, 9.063))); // log2 value 3.18
1364// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(126, 10.2)));
1365// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(159, 5.58)));
1366// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(200, 4.96)));
1367// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(251, 5.46)));
1368// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(318, 3.14)));
1369// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(400, 3.18)));
1370// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(503, 3.34)));
1371// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(636, 2.41)));
1372// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(800, 2.41)));
1373// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(1006, 2.48)));
1374// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(1273, 1.92)));
1375// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(1600, 1.91)));
1376// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(2011, 1.91)));
1377// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(2546, 1.65)));
1378// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(3200, 1.67)));
1379// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(4022, 1.68)));
1380// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(5091, 1.4)));
1381// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(6400, 1.38)));
1382// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(8045, 1.36)));
1383// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(10183, 1.38)));
1384// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(12800, 1.38)));
1385// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(16090, 1.38)));
1386// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(20366, 1.34)));
1387// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(25600, 1.33)));
1388// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(32180, 1.35)));
1389// aCameraGainReadNoiseVector->push_back(*(new OptimalExposure::CameraGainReadNoise(40731, 1.34)));
1390
1391
1392// readModeNumber = 0;
1393// readModeName = "Standard";
1394
1395// aCameraGainReadModeVector = new QVector<OptimalExposure::CameraGainReadMode>();
1396// aCameraGainReadModeVector->push_back(*(new OptimalExposure::CameraGainReadMode(readModeNumber, readModeName,
1397// *aCameraGainReadNoiseVector)));
1398
1399// gainSelection = new QVector<int>( { 100, 125, 160, 200, 250, 320, 400, 500, 640, 800, 1000, 1250, 1600, 2000, 2500, 3200, 4000, 5000, 6400, 8000, 10200, 12800, 16000, 20400, 25600, 32000, 40000 } );
1400
1401// anImagingCameraData = new OptimalExposure::ImagingCameraData(cameraId, OptimalExposure::SENSORTYPE_COLOR,
1402// OptimalExposure::GAIN_SELECTION_TYPE_ISO_DISCRETE, *gainSelection, *aCameraGainReadModeVector);
1403// anImagingCameraData->setDataClassVersion(1);
1404// OptimalExposure::FileUtilityCameraData::writeCameraDataFile(anImagingCameraData);
1405
1406
1407
1408//}
1409
KIO::mkpath
KIOCORE_EXPORT MkpathJob * mkpath(const QUrl &url, const QUrl &baseUrl=QUrl(), JobFlags flags=DefaultFlags)
KStandardShortcut::find
const QList< QKeySequence > & find()
QDir::filePath
QString filePath(const QString &fileName) const const
QDir::mkpath
bool mkpath(const QString &dirPath) const const
QFlags::toInt
Int toInt() const const
QNetworkReply::downloadProgress
void downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
QNetworkReply::errorOccurred
void errorOccurred(QNetworkReply::NetworkError code)
QObject::destroyed
void destroyed(QObject *obj)
QObject::tr
QString tr(const char *sourceText, const char *disambiguation, int n)
QString::fromLatin1
QString fromLatin1(QByteArrayView str)
QString::fromStdString
QString fromStdString(const std::string &str)
QString::number
QString number(double n, char format, int precision)
QString::replace
QString & replace(QChar before, QChar after, Qt::CaseSensitivity cs)
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Fri May 3 2024 11:49:50 by doxygen 1.10.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.